Les différences entre libre dans C et delete en C++?

Il y a deux notions de delete en C++: l'Un est la opérateur, a déclaré que ::operator delete(void*), qui, fondamentalement, seulement libère de la mémoire et n'est pas généralement considéré par la plupart des programmeurs. L'autre est le supprimer l'expression, delete p;, où p est un T*. L'expression appelle le destructeur de l'objet pointé par p (et puis libère la mémoire), qui est d'une importance cruciale pour le langage C++, qui n'a pas d'analogue dans C.

En règle générale, vous paire new expressions avec delete expressions, et malloc() appels de fonction avec free() appels de fonction:

T * p = new T;        //constructor called!
delete p;             //destructor called!

void * x = malloc(5); //just raw memory
free(x);              //freed

---

Partie avancée (pas en réponse à la discussion de la question)

Dynamique de durée de vie des objets en C++ suit cette tendance générale: l'allocation d', construire, détruire, désallouer. La norme new expression effectue la répartition et à la construction, alors que la norme delete expression effectue la destruction et la désallocation.

Vous pouvez écrire le processus manuellement:

T * p = (T*)::operator new(sizeof(T));   //allocate raw memory
p = new (p) T;                           //call the constructor ("placement new")

/*...*/

p->~T();                                 //destroy the object
::operator delete(p);                    //deallocate the memory

En fait, si vous avez vraiment envie de mettre en œuvre Bébé C++, vous pouvez définir la opérateurs comme malloc/free:

void * operator new(size_t n) { return malloc(n); }
void   operator delete(void * p) { free(p); }

Le réel C++ magie se produit en vertu de la new et delete expressions: La norme new expression appelle le constructeur (un new expression est la seulement façon d'appeler un constructeur de C++!) après répartition, alors que la norme de supprimer l'expression appelle le destructeur avant de libération de la mémoire.

Pourquoi "formule standard"? Eh bien, vous pouvez également définir et de surcharge de nombreuses autres versions de new et delete opérateurs. Cependant, il y a une importante asymétrie: même si vous pouvez utiliser un custom new opérateur personnalisé dans un new expression (généralement surnommé "le placement de nouveaux"), il n'y a pas d'équivalent "placement-supprimer" de l'expression. Donc, chaque fois que vous utilisez un personnalisé new expression, vous devez appeler manuellement le destructeur avant l'appel de la correspondance personnalisée supprimer opérateur:

T * p = new (A, B, C) T;                          //some custom new expression

//Entirely equivalent version:

T * p = (T*) ::operator new(sizeof(T), A, B, C);  //this is your custom overload
T * p = new (p) T;                                //std. placement-new expression calls constructor

/* ---- later ---- */

p->~T();                                          //Must destroy manually!
::operator delete(p, A, B, C);                    //your matching custom overload

Noter qu'il n'existe pas une coutume de supprimer l'expression delete (A,B,C) p'!

Pour être complet, le placement standard de nouveaux de l'opérateur, dont le but est d'appeler un constructeur, est commandée par la norme sous la forme suivante:

void * operator new(size_t, void * p) { return p; }

Il est correspondant delete opérateur est également chargé, le nom de ne rien faire:

void operator delete(void * p, void *) { }

Vous pouvez le voir dans l'exemple ci-dessus pourquoi cela est nécessaire.

Il est important de toujours surcharge des versions personnalisées de new et delete en paires! La raison en est que si la construction de l'objet échoue avec une exception dans le constructeur, puis la mémoire est libérée par un appel à la delete opérateur qui correspond à la délinquance new expression.

---

Deuxième mise à jour: être d'exception-safe, nous devons considérer que le constructeur de T pourrait jeter:

Version 1:

try {
  T * p = new (A, B, C) T;
  /* ... */
  p->~T();
  ::operator delete(p, A, B, C); //automatically invoked if T::T() throws!
}
catch(...) { }

Version 2:

void * addr = ::operator new(sizeof(T), A, B, C);
try {
  T * p = new (addr) T;  //might throw
  /* ... */
  p->~T();
  //::operator delete(p, addr); //ditto as in (1), but does nothing
}
catch(...) { }
::operator delete(addr, A, B, C);

OriginalL'auteur Kerrek SB

Ils ne sont pas les mêmes. Le delete opérateur en C++ appelle le destructeur de l'objet, qui, en fonction de la mise en œuvre, devrait libérer de la mémoire. Le delete fonction peut également être surchargé, où free ne peut pas.

OriginalL'auteur Evan Mulawski