Ne delete sur un pointeur vers une sous-classe d'appeler le destructeur de la classe de base?

Le destructeur de A à exécuter lorsque sa durée de vie est plus. Si vous voulez sa mémoire pour être libérés, et le destructeur de l'exécuter, vous devez le supprimer si il a été alloué sur le tas. Si elle a été alloué sur la pile, cela se fait automatiquement (c'est à dire quand elle est hors de portée; voir RAII). Si c'est un membre d'une classe (et non pas un pointeur, mais un membre à part entière), puis ce sera le cas lorsque l'objet est détruit.

class A
{
    char *someHeapMemory;
public:
    A() : someHeapMemory(new char[1000]) {}
    ~A() { delete[] someHeapMemory; }
};

class B
{
    A* APtr;
public:
    B() : APtr(new A()) {}
    ~B() { delete APtr; }
};

class C
{
    A Amember;
public:
    C() : Amember() {}
    ~C() {} //A is freed /destructed automatically.
};

int main()
{
    B* BPtr = new B();
    delete BPtr; //Calls ~B() which calls ~A() 
    C *CPtr = new C();
    delete CPtr;
    B b;
    C c;
} //b and c are freed/destructed automatically

Dans l'exemple ci-dessus, chaque delete et delete[] est nécessaire. Et pas de "supprimer" est nécessaire (ou en effet en mesure d'être utilisé) où je n'ai pas l'utiliser.

auto_ptr, unique_ptr et shared_ptr etc... sont très bien pour faire cette gestion de durée de vie beaucoup plus facile:

class A
{
    shared_array<char> someHeapMemory;
public:
    A() : someHeapMemory(new char[1000]) {}
    ~A() { } //someHeapMemory is delete[]d automatically
};

class B
{
    shared_ptr<A> APtr;
public:
    B() : APtr(new A()) {}
    ~B() {  } //APtr is deleted automatically
};

int main()
{
    shared_ptr<B> BPtr = new B();
} //BPtr is deleted automatically

Il est nommé "destructeur", pas "déconstructeur".

À l'intérieur du destructeur de chaque classe, vous devez supprimer toutes les autres variables de membre qui ont été affectés par la nouvelle.

edit: Pour clarifier les choses:

Dire que vous avez

struct A {}

class B {
    A *a;
public:
    B () : a (new A) {}
    ~B() { delete a; }
};

class C {
    A *a;
public:
    C () : a (new A) {}        
};

int main () {
    delete new B;
    delete new C;
}

L'allocation d'une instance de B, puis de la suppression est propre, parce que le B alloue à l'interne seront également supprimés dans le destructeur.

Mais les instances de la classe C est une fuite de mémoire, car elle alloue une instance de A qui il ne se relâche pas (dans ce cas C ne dispose même pas d'un destructeur).

Vous devez supprimer Un vous-même dans le destructeur de B.

Je me demandais pourquoi ma classe " destructeur n'a pas été appelé. La raison était que j'avais oublié d'inclure la définition de la classe (#include "de la classe.h"). Je n'avais qu'une déclaration comme "classe A", et le compilateur a été heureux avec elle et laissez-moi appeler "supprimer".

Le destructeur de l'objet de classe A sera appelée uniquement si l'option supprimer est appelée pour un objet. Assurez-vous de supprimer le pointeur dans le destructeur de la classe B.

Pour un peu plus d'information sur ce qui se passe lors de la supprimer est appelée sur un objet, voir:
http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.9

Vous avez quelque chose comme

class B
{
   A * a;
}
B * b = new B;
b->a = new A;

Si vous appelez ensuite delete b;, rien ne se passe à un, et vous avez une fuite de mémoire. En essayant de se rappeler à delete b->a; n'est pas une bonne solution, mais il ya un couple de d'autres.

B::~B() {delete a;}

C'est un destructeur de B qui va supprimer un. (Si a est 0, que supprimer ne fait rien. Si a n'est pas 0 mais n'a pas de point à la mémoire de nouveau, vous obtenez tas de corruption.)

auto_ptr<A> a;
...
b->a.reset(new A);

De cette façon, vous n'avez pas comme un pointeur, mais plutôt un auto_ptr<> (shared_ptr<> sera de faire aussi bien, ou d'autres pointeurs intelligents), et il est automatiquement supprimé lorsque b est.

De ces manières fonctionne bien, et j'ai utilisé à la fois.