Delete appelle-t-il le destructeur?

Question

J'ai une classe (Un) qui utilise un tas d'allocation de mémoire pour l'un de ses champs. La classe A est instancié et stocké dans un champ de pointeur dans une autre classe (B).

Quand je suis fait avec un objet B, j'ai appeler delete, qui, je suppose appelle le destructeur... Mais est-ce l'appel du destructeur de la classe A?

Edit:

Pour les réponses, je prends ça (merci de modifier si nécessaire):

1. delete instance de B appels B::~B();
2. qui demande A::~A();
3. and A::~A devrait explicitement delete tous allouées sur la pile variables membres d'Une;
4. et enfin le bloc de mémoire stockage de ladite instance de B est renvoyé à la tas - lorsque la nouvelle a été utilisé, il dispose d'un bloc de mémoire sur le tas, alors invoqué des constructeurs pour l'initialiser, maintenant, après toutes les destructeurs ont été invoquées pour finaliser l'objet le bloc où l'objet résidé est retourné sur le segment.

Answer 1

Le destructeur d'Une à 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

Answer 2

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

À l'intérieur, le 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:

Disons 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).

Answer 3

Si vous avez un pointeur habituel ( A* ), le destructeur ne sera pas appelé (et la mémoire de l'instance A ne sera pas libérée non plus) à moins que vous ne fassiez delete explicitement dans le destructeur de B . Si vous souhaitez une destruction automatique, consultez les indicateurs intelligents tels que auto_ptr .

Answer 4

Vous devriez supprimer A vous-même dans le destructeur de B.