Modification de pointeur non effective à la sortie de la fonction

Version imprimable

Voici une fonction qui est censé parcourir récursivement le arbre :

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
void Graphe::creerSousProgramme(Programme* sousProg)
{
    int total = sousProg->getTotalSousProg();
    int position = -1;
 
    Programme *tmp, *tmp2;
 
    for(int i = 0 ; i < total ; i++)
    {
        tmp = sousProg->getSousProg(i);
        for(int j = 0 ; j < tmp->getTotalSousProg() ; j++)
        {
            tmp2 = tmp->getSousProg(j);
 
            if((position = racine->getPosition(tmp2->getAdressDeb())) != -1)
            {
                tmp2 = racine->getSousProg(position);
 
                if(tmp2->getTotalSousProg() > 0)
                    creerSousProgramme(tmp2);
            }
        }    
    }
}

Peut-on me dire pourquoi je n'arrive pas à récupérer le résultat dans mon pointeur ?
Quand je l'affiche j'ai toujours celui de départ.

16/01/2008, 01h24
JolyLoic

Qu'entends-tu par récupérer ? Ta fonction ne retourne pas de valeur, ne prend pas d'arguments par référence, et ne modifie (a priori, faudrait voir le reste du code pour confirmer) que des variables locales. Je ne vois donc pas trop comment tu t'attends à récupérer quoi que ce soit.
16/01/2008, 01h29
Kerod

Ben en fait je voulais récupérer le contenu modifier directement par le pointeur dans le prototype de la fonction.

En tout cas il est bien modifié mais seulement dans la fonction ce qui fait que l'appel récursif n'a aucun effet (normal il n'a pas de fils) et le retour pour l'affichage n'affiche pas les modifications.

Qu'est-ce qui va pas dans mon code ?
16/01/2008, 02h57
Pacorabanix

ta fonction appelle des fonctions dont le nom commence par get, donc je suppose qu'elles ne modifient rien. Le seule variable de ta classe que tu modifies est position. Donc je répète ce que JolyLoic a dit, ta fonction ne modifie apparemment rien du tout. C'est un problème de conception.

Apparemment tu crées une sorte d'arbre de programmes et sous-programmes c'est cela ? Dis nous en plus sur ce que ton code doit faire.

En fait c'est plus compliqué que ça.

Au premier niveau j'ai un vecteur contenant toutes mes adresses. je veux donc parcourir toutes ces adresses afin de les mettre dans les enfants vu que chaque enfant contient lui aussi un vecteur sauf que là il y a pas d'adresses de fin.

Le but est donc de remplacer les sous-enfants par un pointeur contenant déjà les données voulu.

J'ai donc modifié le operator= pour pouvoir effectuer mon affection d'où le tmp2.

Pour faire plus simple voilà mon operator=
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 //operateur d'affectation Programme& Programme::operator=(const Programme& 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 = prog.sousProgramme; return *this; }
Mon sousProgramme est un vector<Programme *>

16/01/2008, 03h11
Pacorabanix
bon là je ne peut continuer plus en détail la discussion tout de suite, mais remarque deja, sauf erreur, que ton = est appliqué sur des pointeurs... :
Code:

1 2 tmp = sousProg->getSousProg(i);
pas sur des objets eux-mêmes ! Donc il me semble que operator= n'est pas appelé. (essaye à coup d'affichage console pour voir)

il faudrait faire une sorte de

Code:

tmp = new Programme;

pour l'initialiser

puis

Code:

*tmp = *(sousProg->getSousProg(i) ) ;

(si getSousProg(i) renvoie un pointeur).

mais même là il y aurait un problème de conception, car finalement ce "tmp" est local, et tu ne le récupères nul part, ou alors je ne vois pas ou. Tu ne le met dans aucun conteneur ou autre pour sauver ce nouvel objet que tu crées par copie avec le =.
16/01/2008, 03h19
Kerod

Je veux juste remplacer le tmp2 par sa nouvelle valeur. En fait je veux éviter de recréer tout mon vector.
16/01/2008, 09h06
JolyLoic
Je suis désolé, mais il y a quelque chose que je ne comprend pas dans ce que tu dis.

Tu parles de remplacer tmp2 par une nouvelle valeur, C'est quoi cette nouvelle valeur ?
Code:

1 2 3 tmp->getSousProg(j); racine->getSousProg(position); autrechose ?
Et en quoi n'est-elle pas remplacée ?
En quoi modifier quoi que ce soit à tmp2 serait sensé avoir un effet sur le reste du programme ? Ou alors, tu voudrais écrire

Code:

*tmp2 = *racine->getSousProg(position);

?

Ton opérateur = ne me semble pas très pertinent. Déjà, je ne te vois pas faire d'affectations d'objets, juste de pointeurs, et de plus, tel qu'il est écrit, je ne vois pas en quoi il diffère de celui que le compilateur aurait généré tout seul si on le lui avait rien dit.
16/01/2008, 09h50
Kerod

En fait je parcours ma racine pour pouvoir créer mes noeuds vu qu'à la racine on a déjà toutes les infos.

Pourquoi ? Tout simplement parce que c'est une lecture de fichier qui récupère toutes ces infos et sont stockées dans notre racine.

Il me reste plus qu'à parcourir les enfants (incomplets) de chaque noeud de la racine. Si je trouve une adresse de début correspondante alors je remplace l'enfant par l'élément de la racine. ce qui veut dire que c'est tmp2 qui prend racine....
16/01/2008, 10h25
yan
Bonjour,
Citation:
Envoyé par Kerod

Voici une fonction qui est censé parcourir récursivement le arbre :

Code:

1 2 3 void Graphe::creerSousProgramme(Programme* sousProg) { }

Peut-on me dire pourquoi je n'arrive pas à récupérer le résultat dans mon pointeur ?
Quand je l'affiche j'ai toujours celui de départ.
Je n'ai pas trop regardé ton code, mais tu modifie un pointeur temporaire nommé sousProg. Si tu veut que ce soit un alias du pointeur que tu passe en paramètre, ce doit être une référence sur pointeur
Code:

1 2 void Graphe::creerSousProgramme(Programme* &sousProg)
Sinon, ne serait t'il pas préférable de retourner le résultat?
16/01/2008, 12h05
Kerod

J'ai essayé avec des return mais rien à faire c'est pour ça que j'ai essayé avec le passage par pointeur.
16/01/2008, 12h24
Médinoc
Pourtant, le return de pointeur est ce qu'on utilise le plus dans des fonctions créatrices qui ne retournent pas de code d'erreur (comme la tienne, qui ne retourne rien d'autre que le pointeur)...
Code:

1 2 3 Programme* Graphe::creerSousProgramme() { }
PS: Si la fonction ne modifie pas l'objet Graphe, elle devrait également être déclarée const.
16/01/2008, 12h27
Kerod

Ben si ça modifie l'objet graphe puisque c'est lui qui contient la racine qui est un pointeur vers un Programme.
16/01/2008, 12h52
Médinoc

OK.
16/01/2008, 12h55
Kerod

Disons que c'est censé car dans le fonction ça modifie mais à l'extérieur non :aie:

Mon problème de modification de mon pointeur est résolu mais maintenant c'est à l'affichage que ça pose problème, c'est surtout au moment de parcourir mon vecteur qu'il bloque.

Alors voilà, j'ai ma fonction qui est censé dupliquer mon Programme, tant que je modifie pas le vecteur initial (avant copie) j'ai pas de soucis après lors du parcourir (j'entends par soucis Segmentation Fault). Mais si je rajoute la ligne pour modifier ben j'ai mon problème. Avez-vous une idée du pourquoi ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 void Programme::copy(const Programme* 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(); sousProgramme.assign( prog->sousProgramme.begin(), prog->sousProgramme.end() ); }
Ce sont les deux dernières lignes qui cassent tout. Pour plus d'infos :

Code:

vector<Programme *> sousProgramme;

Avez-vous une idée ?

17/01/2008, 09h15
Médinoc

Ne faudrait-il pas dupliquer chaque Programme du vecteur et non seulement leurs pointeurs ?
17/01/2008, 12h46
Kerod

Qu'entends-tu par là ? :roll:

Là actuellement ça fonctionne sauf que lors du parcours il n'arrive pas à récupérer un élément de mon vector malgré le fait qu'il contient des éléments.

Par exemple il arrive pas à récupérer la position 0, et Seg Fault:aie:
17/01/2008, 13h55
yan

Citation:

Envoyé par Kerod

Qu'entends-tu par là ? :roll:

Là actuellement ça fonctionne sauf que lors du parcours il n'arrive pas à récupérer un élément de mon vector malgré le fait qu'il contient des éléments.

Par exemple il arrive pas à récupérer la position 0, et Seg Fault:aie:

??
17/01/2008, 14h34
Kerod

Ben oui il fonctionne à 50%. Lors de la copie tout se passe bien.

Lors de l'affichage et de l'accession du vector ben parfois à tous les coups il me mets un Seg Fault alors que pour d'autres non. Le plus étonnant c'est que je demande l'affichage de nombres d'éléments dans mon vecteur, il me sort un nombre positif mais si je lui dis affiche moi l'élément 0 = Erreur
17/01/2008, 14h55
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...
17/01/2008, 14h57
Kerod

ET si c'est bien ça, comment l'en empêcher ? :roll:
17/01/2008, 14h59
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 ?

Hmmm.

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

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
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);
    }
}

17/01/2008, 15h52
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()...

Tout simplement pour ça :

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

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é. :roll:

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

17/01/2008, 17h17
Médinoc

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

Bonjour.
Tu as une belle fuite mémoire

Code:

sousProgramme.clear();

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

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

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();

17/01/2008, 18h15
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. :aie:

Sauf si vous avez une idée