Discussion :

[Médinoc]

À mon avis, c'est parce que des pointeurs sont copiés, puis les objets pointés détruits, alors que le vecteur contient toujours les pointeurs...

[Kerod]

ET si c'est bien ça, comment l'en empêcher ?

[Médinoc]

En copiant les objets eux-mêmes et non juste les pointeurs quand tu copies tes vecteurs ?

Ou en utilisant les Smart Pointers de Boost, notamment les shared_ptr<> ?

Ou encore, pourquoi pas, en implémentant chaque arbre comme une classe COM ?

[Kerod]

Hmmm.

Maintenant c'est pire : Processus arrêté au lieu de seg fault

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
void Programme::copy(const Programme* prog)
{
    //*(this) = (*prog);
 
    adresse_deb = prog->adresse_deb;
    adresse_fin = prog->adresse_fin;
    identification = prog->identification;
 
    size = prog->size;
    nbAppel = prog->nbAppel;
 
    recursif = prog->recursif;
    sse = prog->sse;
    x87 = prog->x87;    
 
    sousProgramme.clear();
    for(unsigned int i = 0; i < prog->sousProgramme.size(); i++)
    {
        Programme *tmp;
 
        tmp = new Programme(* prog->sousProgramme[i]);        
        sousProgramme.push_back(tmp);
    }
}

[Médinoc]

Ben il faut voir aussi tes constructeurs de copie...
D'ailleurs, j'ai du mal à comprendre pourquoi tu fais une fonction membre copy()...

[Kerod]

Tout simplement pour ça :

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
void Graphe::modifierNoeud(Programme* sousProg)
{
    int nbRacine = sousProg->getTotalSousProg();
 
    Programme *tmpNoeud = NULL;
    Programme *tmpSousNoeud = NULL;
 
    for(int i = 0 ; i < nbRacine ; i++)
    {
        tmpNoeud = sousProg->getSousProg(i);
        int nbSousNoeud = tmpNoeud->getTotalSousProg();
 
        for(int j = 0 ; j < nbSousNoeud ; j++)
        {
            tmpSousNoeud = tmpNoeud->getSousProg(j);
            if(tmpSousNoeud->getAdressFin().empty())
            {
                int position = racine->getPosition(tmpSousNoeud->getAdressDeb());
 
                if(position > -1)
                {
                    tmpSousNoeud->copy(racine->getSousProg(position));
 
                    modifierNoeud(tmpSousNoeud);
                }
            }
        }
    }
}

Mon constructeur :

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
Programme::Programme(const Programme& p)
{
    adresse_deb = p.adresse_deb;
    adresse_fin = p.adresse_fin;
    identification = p.identification;
 
    size = p.size;
    nbAppel = p.nbAppel;
 
    recursif = p.recursif;
    sse = p.sse;
    x87 = p.x87;
 
    for(unsigned int i = 0; i < p.sousProgramme.size(); i++)
    {
        Programme *tmp;
 
        tmp = new Programme(* p.sousProgramme[i]);        
        sousProgramme.push_back(tmp);
    }
}

En fait ça fonctionne j'ai l'impression mais ce doit être la récursivité qui coince si j'ai un trop grand arbre. D'où le processus arrêté.

Il va falloir que je trouve un moyen pour créer tout ça.

[Médinoc]

Donc, copy() est l'équivalent d'un opérateur = virtuel ?

[yan]

Bonjour.
Tu as une belle fuite mémoire

Code :

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

sousProgramme.clear();

car sousProgramme est un vecteur de pointeur. Donc la mémoire n'est pas désalloué par clear.
Remplace par

Code :

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

1
2
3
4
5
 for(unsigned int i = 0; i < sousProgramme.size(); ++i)
    {
        delete sousProgramme[i];        
    }
sousProgramme.clear();

Ou avec les iterator

Code :

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

1
2
3
4
5
6
7
8
 
std::vector<Programme *>::iterator it;
 
for(it =sousProgramme.begin();it !=sousProgramme.end(); ++it)
    {
        delete *it;        
    }
sousProgramme.clear();

[Kerod]

Effectivement pour la fuite. Je la modifie.

Sinon pour l'opérateur virtuel oui.

Sinon ça ne changera rien au fait que je change tout ça. C'est surtout dans le parcours que ça bloque car trop long. J'analyse un fichier contenant 1500 programme. Et pour chacun d'entre eux je voulais rajouter toutes les données de manière récursive. Mais visiblement c'est trop lourd pour lui. Donc je vais me limiter à 3 noeuds.

Sauf si vous avez une idée