Suppression d'un objet avec un destructeur privé

Question

Comment est-il possible de supprimer un objet avec un destructeur privé dans le code suivant? J'ai réduit le programme réel à l'exemple suivant, mais il compile et fonctionne toujours.

class SomeClass; 

int main(int argc, char *argv[]) 
{ 
    SomeClass* boo = 0; // in real program it will be valid pointer 
    delete boo; // how it can work? 

    return -1; 
} 

class SomeClass 
{ 
private: 
    ~SomeClass() {}; // ! private destructor ! 
}; 

Answer 1

Vous essayez de supprimer l'objet de type de classe incomplète. C++ standard dit que vous aurez un comportement non défini dans ce cas (5.3.5/5):

Si l'objet supprimé est de type classe incomplète au moment de la suppression et la classe complète a un non-trivial destructeur ou une fonction de désallocation, le comportement est indéfini.

Pour détecter ces cas, vous pouvez utiliser boost::checked_delete:

template<typename T> 
inline void checked_delete(T* p) 
{ 
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; 
    (void) sizeof(type_must_be_complete); 
    delete p; 
} 

Answer 2

Ce code provoque un comportement indéfini (UB). Il est UB en C++ à delete un objet de type incomplet ayant un destructeur non trivial. Et dans votre code le type SomeClass est incomplet au point de delete, et il a un destructeur non trivial. Les compilateurs émettent généralement un avertissement à ce sujet, car en C++ formellement ce n'est pas une violation de contrainte. Donc, à proprement parler, votre code ne "fonctionne" pas. Il simplement compile et fait quelque chose undefined lors de l'exécution.

Le compilateur n'est tout simplement pas nécessaire pour intercepter cette erreur. La raison en est que cela pourrait être parfaitement bien si votre objet possède un destructeur trivial. Le compilateur n'a aucun moyen de savoir quel genre de destructeur ce type aura finalement, donc il ne peut pas dire avec certitude s'il s'agit d'une erreur ou non.

Answer 3

Car le type SomeClass n'est pas complètement déclaré lors de l'appel operator delete.

La suppression d'un tel pointeur est un comportement indéfini, mais en pratique, la plupart des compilateurs libéreraient simplement la mémoire (si le pointeur n'était pas NULL) et n'appelleraient pas le destructeur.

Par exemple, g ++ vous donnera un avertissement au sujet de cette question:

foo.cpp: In function 'int main(int, char**)': 
foo.cpp:6: warning: possible problem detected in invocation of delete operator: 
foo.cpp:5: warning: 'boo' has incomplete type 
foo.cpp:1: warning: forward declaration of 'struct SomeClass' 
foo.cpp:6: note: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined.