utilisation de pointeur Intelligent

Bonjour.

Depuis une discutions sur les pointeurs, j'ai suivis les conseils donnés et me suis résolu a utiliser des pointeurs intelligents, a savoir, ici, boost::shared_ptr.
J'ai un petit soucis, et je pense que cela vient justement de pointeurs de ce type.

J'ai un vector d'objet, dont chaque objet contient 2 boost::shared_ptr d'autres objets, qui servent a recevoir/envoyer leur coordonnées pour l'affichage et pour les collision. Tout fonctionne très bien, jusqu'au moment ou je décide de supprimer l'un de ces objets ainsi:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

for(vector<Objet>::iterator it = m_objet.begin() ; it != m_objet.end() ; it++) { it->rafraichi(); if(!it->renvoiVie()) { m_objet.erase(it); it = m_objet.begin() ; } }

---

il plante alors et me dit ceci en console : " pure virtual method called // terminate called without an active exception "

Une question me vient donc, quand aux boost::shared_ptr:

Si on envoi un boost::shared_ptr<Objet> a un autre objet, faut-il lui indiquer si l'objet est détruit (donc la référence), si en l'occurence, cela peut être la source du plantage, et si c'est le cas, comment le faire?

Merci si vous pouvez m'aider :)

Bonjour,

Tu ne peux pas utiliser le C++11/C++14 à la place d'utiliser boost ici ?

Pourquoi des shared_ptr ? Des unique_ptr ne conviennent pas ?

Je ne vois pas de raison pour que ça plante ici, tu pourrais donner plus de code ? Celui de Objet par exemple.

Après, si Objet est une classe de base avec une fonction virtuelle pure parmi rafraichi, renvoiVie ou son destructeur, alors, pas de surprise à ce que ça explose, car dans ton vecteur tu stockes des Objet et pas des pointeurs (au sens large : nu, unique_ptr, shared_ptr ou weak_ptr) sur Objet

Merci pour vos réponses :)

voici le code de mon objet.

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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

class CharbonPetit2 { public: CharbonPetit2();   //CharbonPetit2 (const CharbonPetit2 &charbonPetitCopie);   ~CharbonPetit2();   //CharbonPetit2& operator = (const CharbonPetit2 charbonPetitCopie); void recoitPtrAfficheur(boost::shared_ptr<Afficheur> ptr_afficheur); void recoitPtrFeuElement(boost::shared_ptr<FeuElement> m_ptr_feuElement); void cree(string nom, sf::Texture *texture, int tailleImageL, int tailleImageH ); void recoitCollisionSimple(int x, int y, int taille); void recoitDepar(int x, int y, int nombreImageDepar); void recoitFin(int x, int y, int nombreImageFin); void positionne(int x, int y); void initialise();   void rafraichi(); void anime(); void collisionne(); void brule();   bool renvoiVie(); string renvoiNom();     private:   boost::shared_ptr<Afficheur> m_ptr_afficheur; boost::shared_ptr<FeuElement> m_ptr_feuElement;   string m_nom; EI m_EI; CollisionSimple m_collisionSimple ; CollisionSimple m_collisionSimpleDeclencheur; sf::Vertex m_vertex[4];   bool m_tip, m_demarre, m_vie , m_animation; float m_x, m_y, m_z; int m_temps; int m_colX, m_colY, m_colTaille; int m_tailleTextureL, m_tailleTextureH, m_tailleImageL, m_tailleImageH; int m_nombreImageDepar, m_nombreImageFin; int m_compteurX, m_compteurY, m_compteurImage, m_deparX, m_deparY , m_finX, m_finY ; float m_compteurTemps;   };

---

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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289

CharbonPetit2::CharbonPetit2(){}   CharbonPetit2::~CharbonPetit2(){}   void CharbonPetit2::recoitPtrAfficheur(boost::shared_ptr<Afficheur> ptr_afficheur) { m_ptr_afficheur = ptr_afficheur; }   void CharbonPetit2::recoitPtrFeuElement(boost::shared_ptr<FeuElement> ptr_feuElement) { m_ptr_feuElement = ptr_feuElement; m_collisionSimple.recoitPtrFeuElement(ptr_feuElement); m_collisionSimpleDeclencheur.recoitPtrFeuElement(ptr_feuElement); }   void CharbonPetit2::cree(string nom, sf::Texture *texture, int tailleImageL, int tailleImageH) { m_demarre = true; m_animation = false; m_vie = true; m_compteurTemps = -37; m_tip = 0;   m_nom = nom; m_tailleTextureL = texture->getSize().x; m_tailleTextureH = texture->getSize().y; m_tailleImageL = tailleImageL; m_tailleImageH = tailleImageH;   m_x = 0; m_y = 0; m_z = 1117777;   m_compteurX = 0; m_compteurY = 0; m_deparX = 0; m_deparY = 0;   m_vertex[0] = sf::Vector2f(m_x ,m_y ); m_vertex[1] = sf::Vector2f(m_x + m_tailleImageL ,m_y ); m_vertex[2] = sf::Vector2f(m_x + m_tailleImageL ,m_y + m_tailleImageH); m_vertex[3] = sf::Vector2f(m_x ,m_y + m_tailleImageH);   m_vertex[0].texCoords = sf::Vector2f(0 , 0); m_vertex[1].texCoords = sf::Vector2f(m_tailleImageL , 0); m_vertex[2].texCoords = sf::Vector2f(m_tailleImageL , m_tailleImageH); m_vertex[3].texCoords = sf::Vector2f(0 , m_tailleImageH);   m_EI.recoitTexture(texture); m_EI.recoitVertex(m_vertex);   }   void CharbonPetit2::recoitCollisionSimple(int x, int y, int taille) { m_collisionSimple.initialise(x, y, taille); m_collisionSimpleDeclencheur.initialise(x, y, taille *2); }   void CharbonPetit2::recoitDepar(int x, int y, int nombreImageDepar) { m_deparX = x; m_deparY = y; m_nombreImageDepar = nombreImageDepar; m_compteurImage = nombreImageDepar; }   void CharbonPetit2::recoitFin(int x, int y, int nombreImageFin) { m_finX = x; m_finY = y; m_nombreImageFin = nombreImageFin; }   void CharbonPetit2::positionne(int x, int y) { m_x = x + m_tailleImageL/2; m_y = y + m_tailleImageH/2;;   }   void CharbonPetit2::initialise() { m_EI.recoitZ(m_y + m_tailleImageH/4); m_ptr_afficheur->recoitEI(&m_EI);   m_collisionSimple.deplace(m_x, m_y); m_collisionSimpleDeclencheur.deplace(m_x, m_y); }   void CharbonPetit2::rafraichi() {   m_tip = false; if(m_ptr_afficheur->renvoiTemps()) { m_temps++; if(m_temps >= 2) { m_temps = 0; m_tip = true; }   }   if(m_demarre) { m_demarre = false; }   this->anime(); this->collisionne();   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// }   void CharbonPetit2::anime() {     if(!m_animation && m_compteurTemps <=-37) { m_compteurX = 0; sf::Vector2f vector2f;   sf::Vector2i pixelPos = sf::Mouse::getPosition(*m_ptr_afficheur->renvoiFenetre()); sf::Vector2f worldPos = m_ptr_afficheur->renvoiFenetre()->mapPixelToCoords(pixelPos);   if(m_collisionSimple.collisionneObjet(worldPos)) { m_compteurX = 1; } }     if(m_tip == 1 && m_animation) { m_compteurX ++; m_compteurImage++;   m_compteurTemps ++; }     if(m_compteurX >= m_tailleTextureH / m_tailleImageL) { m_compteurX = 0; m_compteurY++; }   if(m_compteurY >= m_tailleTextureH / m_tailleImageH) { m_compteurX = m_deparX; m_compteurY = m_deparY; }   if(m_compteurImage >= m_nombreImageFin) { m_compteurX = m_deparX; m_compteurY = m_deparY; m_compteurImage = m_nombreImageDepar; }       m_vertex[0] = sf::Vector2f(m_x ,m_y ); m_vertex[1] = sf::Vector2f(m_x + m_tailleImageL ,m_y ); m_vertex[2] = sf::Vector2f(m_x + m_tailleImageL ,m_y + m_tailleImageH); m_vertex[3] = sf::Vector2f(m_x ,m_y + m_tailleImageH);   m_vertex[0].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX , m_tailleImageH * m_compteurY); m_vertex[1].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX + m_tailleImageL , m_tailleImageH * m_compteurY); m_vertex[2].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX + m_tailleImageL , m_tailleImageH * m_compteurY + m_tailleImageH); m_vertex[3].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX , m_tailleImageH * m_compteurY + m_tailleImageH);     m_EI.recoitVertex(m_vertex); }   void CharbonPetit2::collisionne() {   m_collisionSimple.rafraichi();   if(m_collisionSimpleDeclencheur.collisionneSimple()) { if(m_ptr_afficheur->renvoiTemps()) { m_compteurTemps++; } if(m_compteurTemps == 0) { this->brule(); } }       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// if(m_compteurTemps < -37 ) { m_compteurX = 0; }     if(m_compteurTemps >= -37 && m_compteurTemps <= 0) { m_compteurX = 2;   if(m_tip == 1) { m_compteurTemps --; }   }   if(m_compteurTemps >= 1 && m_compteurTemps <= 1117) { if(m_compteurImage ==9) { m_deparX = 0; m_deparY = 1; m_nombreImageDepar = 16;   m_finX = 5; m_finY = 1; m_nombreImageFin =21; } } if(m_compteurTemps == 117) { this->recoitFin(5,2,37); }   if(m_compteurImage >= 36) { m_vie = false; //m_colision.detruit(); }         }     void CharbonPetit2::brule() { m_animation = true; m_compteurTemps++;   if(m_compteurTemps == 1) { m_compteurX = 2; m_compteurY = 0; m_nombreImageDepar = 2; m_compteurImage = 2;   m_deparX = 2; m_deparY = 0; m_nombreImageDepar = 2;   m_finX = 5; m_finY = 1; m_nombreImageFin = 21; }     }   bool CharbonPetit2::renvoiVie() { return m_vie; }   string CharbonPetit2::renvoiNom() { return m_nom; }

---

AMA il y a plus simple que ce que tu fais là, c'est quoi le contexte générale de ton application ?

Tu as des fonctions virtuelles pures dans ton code ? En particulier dans Afficheur/FeuElement, si c'est le cas tu peux faire voir la hiérarchie correspondant aux classes déclarant ces fonctions ?

Citation:

---

AMA il y a plus simple que ce que tu fais là

---

C'est a dire? sur quoi?

Citation:

---

c'est quoi le contexte générale de ton application ?

---

C'est un jeu vidéo 2D en vue isométrique. J'utilise SFML, code::block.

Citation:

---

Tu as des fonctions virtuelles pures dans ton code ? En particulier dans Afficheur/FeuElement

---

En fait, je n'ai pas dirrectement de fonction virtuelle pure (a moins que je me trompe sur ce qu'est une fonction virtuelle pure :aie:), car je n'utilise pour l'instant pas l'héritage...Que des class en dure, si je puis dire....
En revanche, j'utilise une class EI, qui est dérivée de sf:: Drawable, qui en contient surement. Je pense d'ailleurs vraiment que ca doit venir de là. J'avais oublié de mettre cette ligne de code, dans mon objet, juste avant qu'il demande sa destruction en changeant m_vie :

Code:

---

1 2 3 4

m_ptr_afficheur->efface(&m_EI); m_vie = false;

---

Qui aurait pu être la cause du plantage...puisque Afficheur affiche toutes les EI dirrectement depuis leurs adresses...

Code:

---

1 2 3 4 5 6

for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++) { m_fenetre->draw(**it); }

---

mais ca plante toujours.

voici la fameuse class EI qui est dérivée de sf::Drawable :

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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

class EI : public sf:: Drawable { public:   friend struct MonFoncteur;   void recoitTexture(sf::Texture *texture) { m_texture = texture; m_actif = true; } void recoitVertex(sf::Vertex vertex[4]) { m_tableauVertex[0] = vertex[0]; m_tableauVertex[1] = vertex[1]; m_tableauVertex[2] = vertex[2]; m_tableauVertex[3] = vertex[3];   } void active(bool actif) { m_actif = actif; } void recoitZ(int z) { m_z = z; }   private:   virtual void draw(sf::RenderTarget& cible, sf::RenderStates states) const { if(m_actif) { cible.draw(m_tableauVertex,4, sf::Quads, m_texture); } }   bool m_actif; float m_z; sf::Vertex m_tableauVertex[4]; sf::Texture *m_texture;   };   struct MonFoncteur { bool operator() (const EI* un, const EI* deux) const { return un->m_z < deux->m_z; } };

---

sf::Drawable a son destructeur déclaré virtuel, et tu ne définis pas de destructeur dans ta classe EI.

Merci, Daïmanu, pour ta réponse.

Comment faudrait-il le faire pour faire au mieu, depuis l'EI ?

Ta classe CharbonPetit2 me semble bien trop compliqué, deux shared_ptr, des pointeurs nues, et des noms étranges (tu peux enlever tout les recoit, c'est évident qu'une fonction reçoit des paramètres, le nom doit décrire ce que fait la fonction, pas le fait qu'elle reçoit des paramètres). Je pense vraiment qu'il y a un problème de conception.

Tu peux faire une exécution pas à pas ? Tu devrais voir qu'elle est la fonction qui pose problème et pourquoi elle est appelée. De là on pourra trouver comment le corriger. Tu peux aussi faire voir le code qui utilise EI ? En particulier comment ils sont stockés.

@Daïmanu: Tant que le destructeur de la classe mère est définie, la classe fille n'a aucun problème pour définir le sien.

Citation:

---

Envoyé par Flob90

@Daïmanu: Tant que le destructeur de la classe mère est définie, la classe fille n'a aucun problème pour définir le sien.

---

Au temps pour moi, je pensais que c'était nécessaire, d'autant plus que j'ai eu des problèmes avec std::unique_ptr si je ne déclarais pas de destructeur (même avec ~c() = default;).

@Daïmanu: Étrange que tu ais eu des problèmes, il y a une problématique avec unique_ptr et le destructeur (dans une situation "par défaut") quand tu utilises un type incomplet, mais ce n'est pas le cas que tu sembles avoir vécu (quoique).

Dans le cas de l'OP, je pense à un appel directe de sf::Drawable::draw après qu'un EI ai été copié en un sf::Drawable.

Merci, Flob90 pour ta réponse.

Citation:

---

c'est évident qu'une fonction reçoit des paramètres

---

dans mon cas, il peut y avoir, par ex: monObjet.rafraichi();

Mais bon, je reconnais que c'est une façon de faire probablement pas très académique.

Citation:

---

Ta classe CharbonPetit2 me semble bien trop compliqué

---

Je veux bien l'admettre. Cependant, il faut préciser qu'il s'agit d'un objet qui:

-permet de s'éclairer quand on passe la souris sur.
-peut/doit être animé, selon plusieurs cycles(l'objet prend feu, il brule, il "explose" et disparait)//ce qui prend beaucoup de texte pour pas grand chose...surtout qu'il partage une texture avec d'autres objets...
-peut s'activer si on s'approche de lui (donc 1 collision ).
-doit bloquer le passage a un objet qui bouge (ici elemenFeu, donc 2 collisions).

Il y a probablement d'autres façons de faire, mais pour l'instant, jusqu'au moment ou j'essaye de les détruires, ca marche. dans mes tests, je peux en utiliser plus de 16000 en même temps sans que ca rame. Pour mon gd, ca me suffit.
Si le seul problème de conception est le vocabulaire, alors, ca ira :D...si par contre c'est une question de programmation/pointeurs, etc... 8O il va faloir que je fasse très attention...

J'ai enlevé les collisions, pour voir, et ca plante toujours, donc ca ne vient probablement pas de là,(surtout qu'il n'y a aucune class hérité là dedans...)

voici ma class Afficheur :

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 25 26 27 28 29 30 31 32 33 34 35 36

class Afficheur { public:   Afficheur(); ~Afficheur();   void recoitEI(EI* entiteImage); void recoitFenetre(sf::RenderWindow *fenetre); void recoitPtrEvent(boost::shared_ptr<sf::Event> ptr_event); void recoitTemps(); void recoitDeltaTemps(float deltaTemps); void efface(EI *eI); void vide();   void affiche();   sf::RenderWindow* renvoiFenetre(); boost::shared_ptr<sf::Event> renvoiPtrEvent(); Vue* renvoiVue(); bool renvoiTemps(); float renvoiDeltaTemps();   private:   sf::RenderWindow *m_fenetre; boost::shared_ptr<sf::Event> m_ptr_event; std::multiset<EI*, MonFoncteur> m_EI; Vue m_vue; float m_deltaTemps; bool m_temps;   };

---

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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

#include "Afficheur.h"   Afficheur::Afficheur(){} Afficheur::~Afficheur(){}   void Afficheur::recoitFenetre(sf::RenderWindow *fenetre) { m_fenetre = fenetre; m_vue.renvoiVue()->setSize(m_fenetre->getSize().x,m_fenetre->getSize().y); m_vue.renvoiVue()->setCenter(m_fenetre->getSize().x/2,m_fenetre->getSize().y/2); }   void Afficheur::recoitPtrEvent(boost::shared_ptr<sf::Event> ptr_event) { m_ptr_event = ptr_event; m_vue.recoitPtrEvent(ptr_event); }   void Afficheur::recoitEI(EI* entiteImage) { multiset<EI*>::iterator it = m_EI.begin(); m_EI.insert(it,entiteImage); }   void Afficheur::recoitDeltaTemps(float deltaTemps) { m_deltaTemps = deltaTemps; }   void Afficheur::recoitTemps() { m_temps = true; }   void Afficheur::affiche() { m_vue.rafraichi(m_temps); m_temps = false;   m_fenetre->setView(*m_vue.renvoiVue());     for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++) { m_fenetre->draw(**it); }   }   void Afficheur::efface(EI *eI) { for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++) { if(*it == eI) { m_EI.erase(it); it = m_EI.begin(); } }   }   void Afficheur::vide() { m_EI.clear(); }     sf::RenderWindow* Afficheur::renvoiFenetre() { return m_fenetre; }   boost::shared_ptr<sf::Event> Afficheur::renvoiPtrEvent() { return m_ptr_event; }   Vue* Afficheur::renvoiVue() { return &m_vue; }   float Afficheur::renvoiDeltaTemps() { return m_deltaTemps ; }   bool Afficheur::renvoiTemps() { return m_temps; }

---

merci pour l'aide ;)

Citation:

---

Envoyé par Flob90

@Daïmanu: Étrange que tu ais eu des problèmes, il y a une problématique avec unique_ptr et le destructeur (dans une situation "par défaut") quand tu utilises un type incomplet, mais ce n'est pas le cas que tu sembles avoir vécu (quoique).

---

En fait c'était dans le cas d'un couple pimpl idiom / unique_ptr où le destructeur, selon gcc, doit être déclaré et défini dans la classe qui possède l'unique_ptr<Impl> pimpl, donc c'ést précisément un type incomplet ;)

Citation:

---

Envoyé par mazertys17

Code:

---

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

void Afficheur::efface(EI *eI) { for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++) { if(*it == eI) { m_EI.erase(it); it = m_EI.begin(); } }   }

---

---

Cette fonction me parait étrange, si tu changes it = m_EI.begin(); par it++; qu'est-ce qui se passe ?

Fais une exécution pas à pas, ça devrait permettre d'avancer pour localiser le problème.

@Daïmanu: C'est Impl qui est incomplet ? Parce que si c'est le cas, peu importe ce que dit gcc, ton code est et reste mauvais peu importe ce que tu fais aux destructeurs (celui de Impl ou de la classe englobante ?).

Citation:

---

Envoyé par Daïmanu

Cette fonction me parait étrange, si tu changes it = m_EI.begin(); par it++; qu'est-ce qui se passe ?

---

Ca plantera.
Sa boucle est correcte, même si je ne l'aurais pas écrite comme ça.

EDIT :

En fait la boucle est effectivement incorrecte mais pas pour la même raison :
Tu effaces un élément, puis tu te places sur begin, puis tu fais ++.
Au final, je crois qu'il restera un élément non testé dans ta liste.
Tu as un multiset, pourquoi ne pas utiliser la fonction find ?

Je confirme que ca vient bien de l'Afficheur/*EI, car si j'enlève ca:

Code:

---

1 2 3

m_ptr_afficheur->recoitEI(&m_EI);

---

et que je detruit l'objet, pas de plantage...Mais du coup plus d'affichage non plus, forcément...

Devrais-je transformer ca:

Code:

---

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

class Afficheur { public:   ... void recoitEI(EI* entiteImage); ...   private:   ... std::multiset<EI*>, MonFoncteur> m_EI; ...

---

en ca :

Code:

---

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

class Afficheur { public:   ... void recoitEI(boost::share_ptr<EI> entiteImage); ...   private:   ... std::multiset<boost::share_ptr<EI>, MonFoncteur> m_EI; ...

---

selon vous ?

Merci, DragonJoker59 pour ta réponse.

je viens d'essayer en changeant :

dans l'afficheur :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void Afficheur::efface(EI *eI) {   std::multiset<EI*>::iterator it ; it = m_EI.find(eI); m_EI.erase(it);   }

---

mais ca plante carrément sans raisons...En même temps, ca m'étonerais que ca vienne de cette fonction "efface" de l'Afficheur, puisque je l'utilise a chaque frame par mon objet Mouvant afin d'actualiser son classement par rapport au zOrder et que ca marchais très bien :

Code:

---

1 2 3 4

m_ptr_afficheur->efface(&m_EI); m_ptr_afficheur->recoitEI(&m_EI);

---

sinon j'ai essayé sur mon objet ceci aussi :

Citation:

---

m_charbonPetit2.erase(it);
it = m_charbonPetit2.begin() ;

---

par

Citation:

---

m_charbonPetit2.erase(it);
it = m_charbonPetit2.end() ;

---

pour voir si va venait du fait qu'il repartait sur begin. Il plante toujours, mais le message n'est plus le exactement le même:

"assertion failed: px != 0, file.../program Files <x86>/Codeblock/boost_1_57_0/boost/smart_ptr/shared_ptr.hpp, line648 "

il me semble que c'est un pb d'allocation de memoire, nan?

Code:

---

1 2	m_EI.erase(eI);

---

Edit: En faite non, tu as changé le comparateur, ça va pas marcher.

je viens d'essayer en changeant :

dans l'afficheur :

Code:

---

1 2 3 4 5 6 7 8 9

void Afficheur::efface(EI *eI) {   std::multiset<EI*>::iterator it ; it = m_EI.find(eI); m_EI.erase(it);   }

---

mais ca plante carrément sans raisons...En même temps, ca m'étonerais que ca vienne de cette fonction "efface" de l'Afficheur, puisque je l'utilise a chaque frame par mon objet Mouvant afin d'actualiser son classement par rapport au zOrder et que ca marchais très bien :

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

Code:

---

1 2 3 4

m_ptr_afficheur->efface(&m_EI); m_ptr_afficheur->recoitEI(&m_EI);

---

ps : je viens d'essayer :

Code:

---

1 2 3

m_EI.erase(eI);

---

ca donne carrément des résultats étonnant: ca supprime d'un coup une rangé de "CharbonPetit2", sans que j'ai rien demandé, et mon objet Mouvant, qui l'utilise a chaque frame, devient super opaque( il recharge autant de fois la même image transparente )...pour planter exactement comme d'habitude...

Et l’exécution pas à pas ?

Citation:

---

Envoyé par Flob90

@Daïmanu: C'est Impl qui est incomplet ? Parce que si c'est le cas, peu importe ce que dit gcc, ton code est et reste mauvais peu importe ce que tu fais aux destructeurs (celui de Impl ou de la classe englobante ?).

---

En gros voila le code coupable :

Code:

---

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

//déclarations (.h) class C { public: ~C(); //visiblement requis private: struct Impl; std::unique_ptr<Impl> pimpl; }; //définitions (.cpp) C::~C() {} //visiblement requis class C::Impl { }

---

@Daïmanu: En effet c'est bon comme ça (j'avais pas compris ce dont tu parlais sans le code :aie:), si tu ne fais rien le destructeur est inline et tu te retrouves donc à détruire ton unique_ptr à un endroit où le type est incomplet, en forçant le destructeur à être dans la même unité de compilation que la classe Impl le type est bien complet au moment de la destruction.

En fait, il semblerait que Daïmanu n'ait pas forcément tord...Il manque sans doute un destructeur a ma EI, qui est probalement en virtual pure...J'ai essayé avec un destruteur basic:

Code:

---

1 2 3

~EI(){}

---

toujours plantage.

En tout cas, ce qui est sur 99% dorénavant, c'est que ca vient bien de la destruction de mon EI :

j'ai essayé simplement de créer un pointeur EI, de l'allouer dynamiquement, et de le détruire...le même plantage.

Merci si vous pouvez m'aider a trouver une piste pour faire un bon destructeur sur cette EI !

Tu veux vraiment pas utiliser ton debugeur pour localiser le problème ? Ça sera plus productif que de spéculer ...

j'ai déjà essayé. Il ne m'indique rien (après je ne sais pas vraiment bien uttiliser un débugger :oops: )...

Ce n'est pas de la spéculation.

Quand j'essaye de détruire une EI, même individuel, il plante.

C'est sur 99%

Citation:

---

Envoyé par mazertys17

Code:

---

1 2 3

m_EI.erase(eI);

---

ca donne carrément des résultats étonnant: ca supprime d'un coup une rangé de "CharbonPetit2", sans que j'ai rien demandé, et mon objet Mouvant, qui l'utilise a chaque frame, devient super opaque( il recharge autant de fois la même image transparente )...pour planter exactement comme d'habitude...

---

Tu as un multiset, donc potentiellement plusieurs fois la même occurence du même élément. Tu essaies d'enlever un élément, donc toutes les occurences ou une seule ?

dison que ca a l'air aléatoire...Mais vu que en l'occurance, il y avait plus de 16000 objets dans mon test, ca doit être logique...
mais le pb est pas là, car cette fonction "efface", bien que étrange, marche...Un find aussi, en fait. Je l'utilise pour d'autres objets, et ca fonctionne sans pb...Je l'ai aussi utilisé pour les 16000 objets d'un coup, il met un petit temps, et tout est effacé sans plantage...mais dès que je touche à une EI...(car la quand j'efface, j'efface simplement l'adresse de l'EI, et non l'EI !!)

le pb, a coup sur, c'est l'EI, qui doit avoir un destructeur en virtual pure ou quelque chose comme ca.

Ton débugeur t'indique la pile d'appel normal, tu vois donc la dernière fonction appelé et celles qui ont conduit à cet appel, ce qui est d'une grande aide. Tu peux aussi exécuté pas à pas, tu verras donc par où passe le programme avant de s’arrêter.

C'est peut-être EI qui pose problème, mais tu n'as aucun des éléments du problème de Daïmanu, la solution ne sera surement pas la même.

@dragonjoker59: En faite il a changé le comparateur, donc erase/find vont l'utiliser ce qui ne donne pas le même comportement que sa boucle où il fait une comparaison des adresses.