Discussion :

[venomelektro]

J ai un probleme d access violation sur un delete this

voila mon probleme en simplifié

class A {

protected:
A(); // construction depuis un manager externe , pas d appel de constructeur direct possible
public:
virtual void CleanUp();
int b1;
}

void A::CleanUp() {

delete this;
}




class B: public A {

protected:
B();
public:
void CleanUp();
int b1;
int b2;
}


void B::CleanUp() {
// divers netoyyage
delete this;
}

Comme le code plante au delete this , je me suis demandé si le this n etait pas un peu foireux , vu qu il heritage et que les objets herités ne sont pas forcement de meme taille que l objet parent

Sinon le delete this est bien le dernier appel de l objet donc c est censé est bon.

[Matthieu Brucher]

Pas étonnant. Quand on ne sait pas ce que ça fait, c'est interdit, les delete this !

[venomelektro]

Pas étonnant. Quand on ne sait pas ce que ça fait, c'est interdit, les delete this !

pourait tu argumenter stp ?

le delete this , je l ai souvent vu dans des codes qui ont l air de marcher...

.. comme par exemple ici dans la faq :

http://c.developpez.com/faq/vc/?page...gPostNcDestroy

en outre ce code fonctionne :

#include <vector>

class A {
public:
A():b(0){};
int b;
void CleanUp(){
delete this;
}

};

std::vector <A*> va;

int _tmain(int argc, _TCHAR* argv[])
{
A* pa = NULL;

for (int j=0;j<5;j++) {
pa = new A();
pa->b = j;
va.push_back(pa);
}


for (int i=0;i<va.size();i++) {

printf("%d\n",va[i]->b);
va[i]->CleanUp();
va[i]=NULL;
}

va.clear();

return 0;
}

mon probleme a l air de venir du delete tout court pluto que du delete this , en fait je stocke des pointeurs dans un std:vector et au moment de nettoyer ce vector , lorsque j itere les pointeurs (qui sont pourtant valides) et que j appelle delete monvecteur[i] ca plante...

[Médinoc]

Il n'y a pas de truc bizarre dans tes destructeurs ?

[Luc Hermitte]

Cet idiome est réservé aux quelques très rares cas où tu reposes sur des cycles de vie bien particuliers qui sont imposés par certains frameworks. Typiquement quand la destruction de l'objet a été requise (un ordre close() a été levé), mais qu'il faille attendre la terminaison de choses que l'objet ne gère pas directement, comme p.ex. tous les threads qui sont liés à l'objet.

En temps normal, on appelle delete sur un objet valide, ou plus simplement, on utilise des pointeurs intelligents.
Rien dans ton exemple ne justifie le "delete this".

Le nétoyage à proprement parler relève de la responsabilité du destructeur!!
Pas d'une fonction qui appelle le destructeur.

Accessoirement. Il ne manquerait pas en plus des destructeurs virtuels ?

NB: la FAQ C++ contient le code type pour libérer les ressources d'un vecteur de pointeurs. Il est aussi possible de définir des std::vector<boost::shared_ptr<> > ou des boost::vector_ptr<> (IIRC) qui sont capables de gérer automatiquement les libérations des objets stockés par pointeur.

[venomelektro]

Merci.

en fait j utilise des constructeurs protected qui sont seulement accessible depuis un manager qui se charge de créer des instances, donc pas de risque que delete this ne delete un objet non crée par un new.

Je vais regarder du coté de boost::vector_ptr et verifier mes destructeurs.

[Matthieu Brucher]

C'est dans quelle sous-bibliothèque, vector_ptr ?