La destruction d'un objet d'une classe fille

bonsoir, pour pouvoir détruire un objet d'une classe fille il faut que le destructeur de la classe mère soit protegé et non virtual ou bien public et virtual
mais pourquoi donc ce code génère une erreure :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#include <iostream>
class mere
{
    protected:
        ~mere()
        {
            std::cout<<"destructeur de mere\n";
        }
};
class fille :public base
{
    ~fille()
    {
        std::cout<<"destructeur de fille\n";
    }
};
int main()
{
    mere *p_b = new fille;
    std::cout<<"Destruction de l'objet :\n";
    delete p_b; // -> Erreur de compilation
    return 0;
}

je viens de remarquer que le destructeur est declaré protegé !
donc la solution sera de le decalré public et virtual

Salut,

Citation:

Envoyé par DLOYAS

je viens de remarquer que le destructeur est declaré protegé !
donc la solution sera de le decalré public et virtual

En effet...

Il est légal de déclarer le destructeur de la classe de base comme étant non virtuel et dans l'accessibilité protégée, mais cela implique une restriction très fortes sur la destructions des instances des classes dérivées dans le sens où nous sommes obligés de les détruire en tant qu'instances du type dérivé que l'on ne peut pas décider de détruire un objet qui "passerait pour être du type de base".

Il est parfois très intéressant d'agir de la sorte, car cela te donne l'assurance qu'une fonction qui prend un pointeur du type de base ne pourra pas essayer d'appeler delete sur ce pointeur (et donc, risquer d'invalider l'objet qu'elle a recu en argument au travers de ce pointeur). Mais cela signifie aussi que "ce qui s'occupera de gérer la durée de vie" des objets de type dérivé devra veiller à... ne pas perdre de vue qu'il s'agit d'objets du type dérivé :aie:

Or, bien souvent, on se trouve dans une situation dans laquelle "on n'en n'a rien à foutre" du type réel des différents objets parce que l'on considère qu'il s'agit de toutes façons d'objet du type de base et que toutes les manipulations qui pourraient être faites se baseront sur ce fait.

Dans cette situation, nous n'allons pas créer une collection différente pour chaque type dérivé, mais plutôt une collection de pointeurs (de préférence intelligents) sur des objets du type de base. Et, pour pouvoir détruire les différents objets, il faut que
la fonction de destruction de l'objet (celle qui appellera delete) puisse accéder au destructeur du type de base et que
le compilateur se rend compte qu'il devra adapter le comportement du destructeur du type de base au type réel de l'objet

Le (1) implique que le destructeur doit être public, le (2) implique que le destructeur doit être virtuel.

Quelques exemples précis :
Mettons que tu aies des Clients et des Fournisseurs, tous deux dérivés de Personne. Tu ne vas jamais "mélanger" les clients et les fournisseurs. Tu vas donc les mettre dans des collections différentes et ou bien tu travailleras sur la liste de tes fournisseurs, ou bien tu travailleras sur la liste de tes clients.

Et une chose est sure : si tu décide, à un moment donné, de travailler avec un pointeur sur une Personne, la fonction qui utilise ce pointeur ne peut faire qu'utiliser l'objet transmis sous la forme de ce pointeur. Tu peux donc déclarer le destructeur de Personne dans l'accessibilité protégée (pour que les classes Client et Fournisseur puissent y accéder) mais non virtuel, car il n'y a aucun besoin de permettre la modification de son comportement.

Maintenant, imaginons que tu veuilles créer des objets qui doivent être affichés. Mettons que la classe de base soit DrawableObject et que tu aies une hierarchie de classe contenant une classe Wall (les murs, lorsqu'il faut les afficher), Stone (des pierres, sur le chemin), Spell (les sorts lancés par les joueurs), PNJ (personnages non joueur) et que sais-je d'autre...

Quel que soit le type réel de tous les objets que tu va créer, tu vas vouloir les placer dans une seule et unique collection afin de pouvoir... provoquer l'affichage de tous les éléments affichables, indépendamment de leur type réel, sous une forme qui pourrait être proche de
Code:

1 2 3 4 // C++11 inside for (DrawableObject * it : maCollection){ it->draw(render); }
Et, bien sur, lorsqu'il s'agira de détruire un des éléments, tu devras le détruire en le connaissant "sous la forme d'un pointeur de type DrawableItem", quel que soit le type réel de l'élément que tu veux détruire, par exemple, sous la forme de
Code:

1 2 3 4 5 // C++11 inside for (DrawableObject * it : maCollection){ delete it; // on aura sans doute eu recours aux pointeurs intelligents mais, // on va dire que c'est pas le cas, uniquement pour l'explication ;) }
Il faudra donc que le destructeur de DrawableItem soit public (pour que le compilateur accepte que tu appelle delete sur le pointeur) et virtuel (pour qu'il (le compilateur) se rende compte que le comportement doit être adapté au type réel de l'objet)

In n'y a aucune règle qui dise, d'une manière ou d'une autre, qu'une situation est plus fréquente que l'autre. La seule règle est de faire le bon choix en fonction de tes besoins ;)