Probleme desallocation d'objets dynamiques dans un std::vector<Objet*> ( destructeur du conteneur )

Bonjour,

je suis sous codeblocks, et je crée un petit moteur 3d pour m'entrainer.
J'ai créé une classe Monde qui contient un tableau vectoriel de pointeurs sur Objets créé dynamiquements, tout fonctionne (création , manipulation , acces)
Sauf lors de la destruction du conteneur qui delete les objets un par un.

ceci donne lieu a une faute de segmentation a la ligne delete.
voici mon code(constructeur , destructeur et methode creerObjet):

Code:

---

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

Monde::~Monde() { for (unsigned int i(0) ; i < m_tableauObjets3d.size(); ++i) { delete m_tableauObjets3d[i]; cout << "objet detruit " << i <<endl; } } void Monde::creerObjet(string chemin) { m_tableauObjets3d.push_back(new Objet3d(chemin)); cout << "objet créé" <<endl; }

---

j'ai cherché a peu pres partout y compris sur ce site,un sujet existe déja mais j'aimerai ne pas faire appel a boost tout de suite étant donné que j'apprend déja a utiliser 4bibliotheques en meme temps , et j'aimerai aussi éviter d'allouer dynamiquement mon std::vector<Objet*> car je trouve que ce n'est pas tres propre.

Mais bon , s'il n'y a pas de meilleure solution.

Je ne vois rien de problématique dans le code que tu nous montres (même si j'aurais certainement fait autrement, par exemple en utilisant un vector<unique_ptr<Object3D>>).

Il doit y avoir ailleurs une erreur de code qui vient corrompre la mémoire, et cette erreur n'a d'effets visibles que quand tu détruits des objets.

A tout hasard, est-ce que tu t'es assuré que ta classe Monde soit non copiable ? Parce que si tu la copies, tu vas copier le vector, quand à la fois l'original et la copie seront détruits, tu vas désallouer deux fois les données dans ton vector, ce qui provoquerait ce genre d'erreurs.

merci pour la rapidité d'intervention.

Mon projet est vraiment simple donc ça m'étonnerait que que mon monde soit copier , mais sinon comment puis-je m'assurer qu'il ne l'est pas?

sinon j'ai pris la décision de sacrifier de la performance en copiant l'Objet pointé , ce qui fait que j'aurai un vecteur d'objets et non plus un vecteur de pointeurs sur objets.

Mais ça ne fonctionne pas non plus et le debugger me renvoie vers la stl,(stl_construct.h)

Code:

---

1 2 3 4 5 6 7 8

/**    * Destroy the object pointed to by a pointer type.    */ template<typename _Tp> inline void _Destroy(_Tp* __pointer) :cry:<---ICI:cry: { __pointer->~_Tp(); }

---

voila mon code:

Code:

---

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

Monde::Monde() {   } Monde::~Monde() {   }   void Monde::creerObjet(string chemin) { Objet3d* dynamiqueTemporaire(new Objet3d(chemin)); m_tableauObjets3d.push_back(Objet3d(*dynamiqueTemporaire)); delete dynamiqueTemporaire; cout << "objet créé" <<endl; }

---

J'ai essayé de faire une std::vector<std::unique_ptr<Objet3d>> , mais il me dit que l unique_ptr n'appartient pas a std:: ,alors que j'ai inclus <memory>

je ne desesperre pas , mais c'est vrai que c'est plutot bloquant cette histoire.

Citation:

---

Envoyé par 3xistential

merci pour la rapidité d'intervention.

Mon projet est vraiment simple donc ça m'étonnerait que que mon monde soit copier ,

---

A vrai dire, cela peut arriver très facilement, il suffit que ton monde soit transmis une seule fois par valeur, plutôt que par référence pour qu'il soit copié, et détruit à la fin de la fonction à laquelle il est transmis

Citation:

---

mais sinon comment puis-je m'assurer qu'il ne l'est pas?

---

En rendant tes (Obje3d et Monde :question:) non copiable et non assignable.

Si tu peux compiler en C++11, cela se fait facilement en déclarant le constructeur par copie et l'opérateur delete sous une forme proche de

Code:

---

1 2 3 4 5 6

class Objet3d{ public: Objet3D(Objet3D const &) = delete; Objet3D& operator = (Objet3D const &) = delete; /* le reste du code */ };

---

Si tu ne disposes pas de cette possibilité (parce que tu ne compile pas en C++11, ou parce que ton compilateur ne supporte pas encore cette possibilité), tu peux déclarer sans les implémenter le constructeur par copie et l'opérateur d'affectation en accessibilité privée sous une forme proche de

Code:

---

1 2 3 4 5 6 7

class Objet3d{ public: /* le reste du code */ private: Objet3D(Objet3D const &) ; Objet3D& operator = (Objet3D const &) ; };

---

(fais simplement pareil pour la classe Monde)

Citation:

---

sinon j'ai pris la décision de sacrifier de la performance en copiant l'Objet pointé , ce qui fait que j'aurai un vecteur d'objets et non plus un vecteur de pointeurs sur objets.

---

C'est une très mauvaise idée car tes Objet3D ont, typiquement, sémantique d'entité, ce qu'il fait qu'ils n'ont pas vocation à être copiés ni assignés.

De plus, il est plus que probable que tu veuilles faire hériter plusieurs classes de ta classe Objet3D.

Si tu utilises Objet3D par valeur, tu peux dire adieux au polymorphisme, et cela risque de poser énormément de problème ;)

Citation:

---

Mais ça ne fonctionne pas non plus et le debugger me renvoie vers la stl

---

Tout fini, tôt ou tard, dans la STL quand tu l'utilises :D

Citation:

---

J'ai essayé de faire une std::vector<std::unique_ptr<Objet3d>> , mais il me dit que l unique_ptr n'appartient pas a std:: ,alors que j'ai inclus <memory>

---

C'est une possibilité offerte par C++11, mais, par défaut, de nombreux compilateurs utilisent encore la norme de 2003 par défaut.

Pour pouvoir utiliser les std::unique_ptr, il faut rajouter l'option de compilation qui fera que ton compilateur utilise la norme de 2011. Sous Gcc, par exemple, cela se fait en rajoutant l'option -std=c++11 à la ligne de commande, et je crois qu'il n'y a que, du coté de Visual Studio, il n'y a que la version 2012 qui permet d'utiliser C++11, et qu'il le fait de manière systématique (mais ne propose par exemple pas encore de la possibilité de déclarer une fonction membre delete, il me semble)

Je suis repassé a la méthode classique d'allocation dynamique selon tes conseils.

J'ai rendu la classe Objet3d et Monde non affectables et non copiables comme tu m'a dit (merci je ne connaissait pas ça) , mais ça n'a rien changé , le debugger renvoie toujours une erreur de SIGSEGV au meme endroit , c'est a dire ici:

Code:

---

1 2 3 4 5

Monde::~Monde() { for(unsigned int i(0) ; i < m_tableauObjets3d.size() ; ++i) delete m_tableauObjets3d[i]; }

---

Quand je déclare Statiquement un Objet3d , toute la classe fonctionne bien , il se charge depuis un .obj , se dessine etc ... et se détruit correctement.

Mais depuis le std::vector<Objet3d*> de class Monde ,il y à toujours une erreur a la suppression...:aie:

Comment auriez vous fait vous?8O

Si ton projet est petit, essaye de le réduire au maximum, jusqu'à avoir un programme court (une centaine de lignes max) qui reproduise le problème. Deux options sont alors possible :
- Soit en faisant cet exercice, tu va trouver toi même le soucis
- Soit tu ne le trouve pas, mais ton code est devenu assez petit pour pouvoir être copié ici pour qu'on le regarde.


Sinon, il existe des programmes pour aider à trouver ce genre d'erreurs, mais rien de magique...

Tout ça pour une erreur dérisoire.
Je faisais appel au destructeur de la classe explicitement:

Code:

---

Monde.~Monde()

---

dans le main...
Merci backlash du Chat Devdotcom.