Discussion :

[Narwe]

Bonjour,

C'est sans doute un problème récurrent sur ce forum et je m'en excuse (ma recherche n'a rien donnée, même sur Google - A noter OC n'est pas accessible en ce moment).

J'ai résumé mon problème dans ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <vector>
#include <string>
#include <iostream>
using namespace std;
class Animal {
    protected:
        string m_s_Nom;
        Animal(string i_s_Nom) {m_s_Nom=i_s_Nom;};
    public:
        ~Animal() {cout << "Mort animal : " << m_s_Nom << endl;};
};
 
class Lion : public Animal {
    public:
        Lion() : Animal("Lion") {};
        ~Lion() {cout << "Le lion est mort" << endl;};
};
 
class Vache : public Animal {
    public:
        Vache() : Animal("Vache") {};
        ~Vache() {cout << "La vache est morte" << endl;};
};
 
int main(int /*argc*/, char** /*argv*/) {
    Lion  *o_Lion;
    Vache *o_Vache;
    vector<Animal*> t_Animaux;
 
    o_Lion = new Lion();
    o_Vache = new Vache();
    delete o_Lion;
    delete o_Vache;
 
    t_Animaux.push_back( new Lion() );
    t_Animaux.push_back( new Vache() );
    for (int i=0;i<t_Animaux.size();i++) {
        delete t_Animaux.back();    // Pb on ne passe par le destructueur de Lion / vache ?!?
        t_Animaux.pop_back();
    }
}

Je n'arrive pas à supprimer correctement mon tableaux d'animaux.
Le programme ne passe que par le code de la classe Animal sans passer par le destructeur de la classe Lion ou Vache.

Je peux le comprendre vu que c'est un tableau d' "Animal" (la classe sinon, j'aurais écrit animaux) mais pour ce genre de chose était un des principes du polymorphisme (si c'est le bon terme).

Comment faire pour détruire un tableau d'objet polymorphe ?

De même avec le code ci-dessous, je passe dans le destructeur d'Animal mais pas dans celle du "Lion" (ce qui est dans la logique de la suppression du tableau).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
o_Animal = new Lion();
delete o_Animal;

Je vous remercie pour votre aide.

[Invité]

Bonsoir,

Deux sujets de la C++ à consulter :

• Pourquoi le destructeur d'une classe de base doit être public et virtuel ou protégé et non virtuel ?
• Pourquoi et quand faut-il créer un destructeur virtuel ?

Attention aussi à cette boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for (int i=0;i<t_Animaux.size();i++) {
    delete t_Animaux.back();    // Pb on ne passe par le destructueur de Lion / vache ?!?
    t_Animaux.pop_back();
}

• Première passe i=0 : t_Animaux {Lion, Vache} (2 éléments), tu détruis le dernier élément Vache, et le supprimes ;
• Deuxième passe : i=1 : t_Animaux {Lion} (1 élément => i<t_Animaux.size() est faux) tu sors donc de la boucle et ne supprimes pas le Lion.

[Narwe]

Merci !

Donc j'obtiens le code suivant qui répond à ma demande.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <vector>
#include <string>
#include <iostream>
using namespace std;
class Animal {
    public:
        string m_s_Nom;
        Animal(string i_s_Nom) {m_s_Nom=i_s_Nom;};
    public:
        virtual ~Animal() {cerr << "Mort animal : " << m_s_Nom << endl;};
};
 
class Lion : public Animal {
    public:
        Lion() : Animal("Lion") {};
        ~Lion() { cerr << "Le lion est mort" << endl; };
};
 
class Vache : public Animal {
    public:
        Vache() : Animal("Vache") {};
        ~Vache() { cerr << "La vache est morte" << endl; };
};
 
int main(int /*argc*/, char** /*argv*/) {
    Lion  *o_Lion;
    Vache *o_Vache;
    vector<Animal*> t_Animaux;
 
    o_Lion = new Lion();
    o_Vache = new Vache();
    delete o_Lion;
    delete o_Vache;
 
    t_Animaux.push_back( new Lion() );
    t_Animaux.push_back( new Vache() );
    for (int i=t_Animaux.size()-1;i>=0;i--) {
        delete t_Animaux.back();
        t_Animaux.pop_back();
    }
 
	Animal *o_Chien;
	o_Chien = new Animal("Chien");
	delete o_Chien;
}

Et merci pour la boucle de suppression!

[Bousk]

Pour une boucle encore plus élégante : while (!vec.empty())

Sinon, tu étais pas loin, le "secret" du polymorphisme tient en son mot-clé virtual !
http://cpp.developpez.com/faq/cpp/?p...ot-cle-virtual

[ternel]

Et à l'usage de références (ou pointeurs), d'où l'usage d'un std::vector<Animal*>.

[Luc Hermitte]

Pour une boucle encore plus élégante : while (!vec.empty())

On a ça aussi dans la FAQ: http://cpp.developpez.com/faq/cpp/?p...d-un-conteneur
Et il ne faut pas oublier les solutions moins risquées que sont boost::ptr_vector<T> et std::vector<std::unique_ptr<T>>.

(en plus du virtual, hein ?)