Class imbriqué : problème de delete

Bonsoir,

J'ai une classe sous cette forme :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class B; class A{ protected: vector <B *> m_b; ... public: ~virtual A(); };   class B : public A{ ... };

---

Et j'ai un problème pour supprimer les objets A.
Je parcours le vecteur m_b en faisant un delete à chaque itération, mais j'ai core dump... Je ne comprend pas.

Bonjour,
ce n'est pas plutôt

Code:

---

virtual ~A();

---

Oui effectivement, j'ai tapé ce message rapidement.

Montre comment tu alloue et delete les pointeur dans ton vecteur

1) Pourquoi avoir un vector<B*> et pas vector<A *> en utilisant le polymorphisme?

2) Effectivement, comme l'ont dit mes collègues au dessus, il faudrait un peu plus de code pour détecter ton problème.
Juste une petite remarque : il existe chez Boost un conteneur spécial pointeur qui te décharge de toute désallocation, c'est automatique... :mrgreen:
-> Tu trouveras de la doc ICI

Bonne continuation,

Poukill

Ouais, vive les ptr_containers!

Citation:

---

Envoyé par poukill

1) Pourquoi avoir un vector<B*> et pas vector<A *> en utilisant le polymorphisme?

---

En fait, la classe B représente un sous programme et son vecteur (de sous programme) ses appels de sous programme.

Ex :

Code:

---

1 2 3 4 5 6 7 8 9

fonction1(){ fonction2(); fonction3(); } fonction2(){ } fonction3(){ }

---

Donc on aura 3 objets B :
B1 son vecteur contiendra B2 et B3
B2 vecteur vide
B3
L'objet A servira à stocker l'ensemble des sous programme.

Voici le destructeur de A :

Code:

---

1 2 3 4 5 6

vector<Sub_program *>::iterator iter_prog; for(iter_prog = m_sub_programs.begin(); iter_prog != m_sub_programs.end(); iter_prog++){ if(*iter_prog != NULL) delete (*iter_prog); }

---

Celui de B détruit seulement ces données à détruire.

Edit:
Pour l'allocation :

Code:

---

1 2 3

Sub_program * sprog = new Sub_program(adress_temp); // Ajoute au vecteur de la classe A m_program->add_sub_program(sprog);

---

Un objet Sous_program contient donc lui aussi des pointeurs vers d'autres objets Sous_program.

Je suis en train de me renseigner sur boost. Merci pour le lien.

TU peux nous montrer le destructeur de B ? :)

Pas de problème.
Voici les destructeurs complets :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Program::~Program(){ vector<Instruction *>::iterator iter_instr; for(iter_instr = m_instructions.begin(); iter_instr != m_instructions.end(); iter_instr++){ delete (*iter_instr); }   vector<Sub_program *>::iterator iter_prog;   for(iter_prog = m_sub_programs.begin(); iter_prog != m_sub_programs.end(); iter_prog++){ if(*iter_prog != NULL) delete (*iter_prog); } cout << "Program deleted" << endl; } Sub_program::~Sub_program(){ cout << "Deleting ssprog : " << hex << m_adr_begin << endl; vector<Instruction *>::iterator iter_instr; for(iter_instr = m_instructions.begin(); iter_instr != m_instructions.end(); iter_instr++){ delete (*iter_instr); } }

---

L'objet A(Program) comporte un vecteur d'instruction et donc B aussi par héritage.

Même si le destructeur est correct, il reste encore THE oubli classique dans ce genre de cas: le constructeur de copie et l'opérateur d'affectation.
Ils doivent bien entendu copier les données pointées. Si cela n'est pas possible (l'utilisation du polymorphisme oo est une très bonne raison) tu dois rendre ta classe non copiable, ce qui pour rappel se fait avec la syntaxe suivante:

Code:

---

1 2 3 4 5 6

class x { ... private: x(const x&); x& operator = (const x&); };

---

Tu es sur d'avoir géré cet aspect correctement?

Et si tu implémentes l'opérateur = , une implémentation conseillée est de passer par une fonction d'échange + le constructeur de copie.

Code:

---

1 2 3 4 5

CUneClasse& CUneClasse::operator=(CUneClasse const & src) { CUneClasse tmp(src); Swap(tmp); }

---

La fonction Swap(), elle, prend en paramètre une référence non-constante et peut être très légère, car elle n'a rien à copier.