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

**3xistential** · 03/08/2013, 19h43

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 :

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

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.

**JolyLoic** · 03/08/2013, 19h53

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.

**3xistential** · 03/08/2013, 21h03

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 :

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

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 :

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

**koala01** · 04/08/2013, 10h46

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

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

En rendant tes (Obje3d et Monde

) 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 :

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

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 :

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

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)

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

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

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)

**3xistential** · 04/08/2013, 18h49

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 :

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

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

Comment auriez vous fait vous?

**JolyLoic** · 04/08/2013, 20h03

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