Discussion :

[Anium]

Bonsoir,

J'ai une classe sous cette forme :

Code :

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

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.

[yan]

Bonjour,
ce n'est pas plutôt

Code :

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

virtual ~A();

[Anium]

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

[Davidbrcz]

Montre comment tu alloue et delete les pointeur dans ton vecteur

[poukill]

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...
-> Tu trouveras de la doc ICI

Bonne continuation,

Poukill

[zais_ethael]

Ouais, vive les ptr_containers!

[Anium]

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 :

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

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 :

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

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 :

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

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.

[poukill]

TU peux nous montrer le destructeur de B ?

[Anium]

Pas de problème.
Voici les destructeurs complets :

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

[zais_ethael]

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 :

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

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?

[Médinoc]

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 :

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

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.