Fonction de l'opérateur delete
La mémoire qui est allouée dynamiquement à l'aide de l'opérateur new peut être libérée avec l'opérateur delete. L'opérateur delete appelle la fonction operator delete, qui restitue la mémoire dans le pool disponible. L'utilisation de l'opérateur delete entraîne l'appel du destructeur de classe (le cas échéant).
Il existe des fonctions globales et de portée de classe operator delete . Seule une fonction operator delete peut être définie pour une classe donnée. Si elle est définie, elle masque la fonction globale operator delete . La fonction globale operator delete est toujours appelée pour les tableaux de n'importe quel type.
La fonction globale operator delete , si elle est déclarée, accepte un argument unique de type void *, qui contient un pointeur vers l'objet à désallouer. Le type de retour est void (operator delete ne peut pas retourner de valeur). Les fonctions operator delete membres de classe existent sous deux formes :
void operator delete( void * );
void operator delete( void *, size_t );
Une seule des deux variantes précédentes peut être présente pour une classe donnée. La première forme fonctionne comme décrite pour la fonction globale operator delete. La deuxième forme accepte deux arguments, le premier étant un pointeur vers le bloc de mémoire à libérer et le second étant le nombre d'octets à libérer. La deuxième forme est particulièrement utile lorsqu'une fonction operator delete de la classe de base est utilisée pour supprimer un objet d'une classe dérivée.
La fonction operator delete est statique. Elle ne peut donc pas être virtuelle. La fonction operator delete obéit au contrôle d'accès, comme décrit dans Contrôle d'accès aux membres.
L'exemple suivant montre les fonctions operator new et operator delete conçues pour consigner les allocations et les désallocations de mémoire :
Exemple
// spec1_the_operator_delete_function1.cpp
// compile with: /EHsc
// arguments: 3
#include <iostream>
using namespace std;
int fLogMemory = 0; // Perform logging (0=no; nonzero=yes)?
int cBlocksAllocated = 0; // Count of blocks allocated.
// User-defined operator new.
void *operator new( size_t stAllocateBlock ) {
static int fInOpNew = 0; // Guard flag.
if ( fLogMemory && !fInOpNew ) {
fInOpNew = 1;
clog << "Memory block " << ++cBlocksAllocated
<< " allocated for " << stAllocateBlock
<< " bytes\n";
fInOpNew = 0;
}
return malloc( stAllocateBlock );
}
// User-defined operator delete.
void operator delete( void *pvMem ) {
static int fInOpDelete = 0; // Guard flag.
if ( fLogMemory && !fInOpDelete ) {
fInOpDelete = 1;
clog << "Memory block " << cBlocksAllocated--
<< " deallocated\n";
fInOpDelete = 0;
}
free( pvMem );
}
int main( int argc, char *argv[] ) {
fLogMemory = 1; // Turn logging on
if( argc > 1 )
for( int i = 0; i < atoi( argv[1] ); ++i ) {
char *pMem = new char[10];
delete[] pMem;
}
fLogMemory = 0; // Turn logging off.
return cBlocksAllocated;
}
À partir de Visual C++ 5.0, le compilateur prend en charge les opérateurs new et delete de tableau membre dans une déclaration de classe. Par exemple :
// spec1_the_operator_delete_function2.cpp
// compile with: /c
class X {
public:
void * operator new[] (size_t) {
return 0;
}
void operator delete[] (void*) {}
};
void f() {
X *pX = new X[5];
delete [] pX;
}
Commentaire
Le code précédent peut être utilisé pour détecter les fuites de mémoire, c'est-à-dire la mémoire qui est allouée sur le magasin libre mais jamais récupérée. Pour effectuer cette détection, les opérateurs new et delete sont redéfinis pour compter l'allocation et la désallocation de mémoire.