Bonjour,

voilà je me remets au dev C++. Et boum erreur de segmentation !
J'ai réduit... réduit le code que voici. J'explique.

J'ai 2 vector de pointeurs : vector<Graphe*>vG et vector<Reference*>vG

- une Reference contient un un Graphe*
- un Graphe peut produire une nouvelle Reference*

on peut donc ajouter au vector une nouvelle Reference* produite par un Graphe* lui meme dans une Reference (du vector). un peu.

le probleme est que quand je fait cette operation a partir d'un iterator du vector<Reference*> Celui est modifié.
Consequence Seg fault !

le code (fichier unique main.cpp):
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
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
 
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <iostream>
 
class Reference; //declaration
 
/****************
* les classes   *
****************/
class Graphe {
    private:
        Graphe* parent;
        std::vector<int> feuilles;
 
    public:
        Graphe(Graphe* par) : parent(par){/***/};//constructeur
        ~Graphe(){/***/};
 
        Reference* insert_feuille(int); //
};
 
class Reference {//type struct
    public:
            Reference(Graphe* pt) : ref(pt) {/***/};
            Reference(const Reference& R) : ref(R.ref){/**copie**/};
            /*
            Reference operator=(const Reference& R){
                if (this != &R) this->ref = R.ref;
                return (*this);
            };
            */
 
            Graphe* ref; //pointeur du graphe
};
 
/************************************
* la methode d'insertion de feuille *
* qui crée une nouvelle référence   *
************************************/
Reference* Graphe::insert_feuille(int n){
    feuilles.push_back(n);
    return new Reference(this);
}
 
struct delete_ptr
{
    template <typename T>
    void operator()(T* pPtr)
    {
        delete pPtr;
    }
};
 
 
/************
* le main   *
************/
 
int main (int argc, char *argv[]) {
 
    //creation d'un vecteur de Graphe* et un vecteur de Reference*
    std::vector<Graphe*> vG;
    std::vector<Reference*> vR;
 
    //on remplie vG
    vG.push_back(new Graphe(NULL));
    //on met une refence dessus
    vR.push_back(new Reference(vG.back()));
 
    //test 1:
    std::cout << "1: " << vG.back() << " = " << vR.back()->ref << std::endl;
    std::cout << vR.front() << " taille :" << vR.size() <<std::endl;
 
    //avec l'utilisation d'iterator
    std::vector<Reference*>::iterator it = vR.begin();
 
    //on regarde l'iterateur
    std::cout << "it: " << *it << std::endl;
    //on met une nouvelle ref
    vR.push_back((*it)->ref->insert_feuille(53));
 
    //test 2:
    std::cout << "2: " << vG.back() << " = " << vR.back()->ref << std::endl;
    std::cout << vR.front() << " taille :" << vR.size() <<std::endl;
    std::cout << "it: " << *it << "<-- ouh la !" << std::endl;
 
    vR.push_back((*it)->ref->insert_feuille(53)); // forcement ça plante...
 
    //on efface
    std::for_each(vG.begin(), vG.end(), delete_ptr() );
    std::vector<Graphe*>().swap(vG);
 
    std::for_each(vR.begin(), vR.end(), delete_ptr() );
    std::vector<Reference*>().swap(vR);
 
    return EXIT_SUCCESS; //enfin...
}
je vois plus là...