Discussion :

[Braise]

Bonjour à tous,

Je rencontre un "léger" problème avec les pointeurs que je n'arrive pas à solutionner. Voici mon code, celui-ci est une espèce d'implémentation d'arbre vraiment très simplifiée. Disons que c'est juste un prétexte pour revoir!

Tout d'abord, voici mon .h avec notamment la définition de la structure Noeud :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct Noeud {
 
        char *mot;
        int cpt;
        struct Noeud *filsGauche;
        struct Noeud *filsDroit;
 
}Noeud;
 
typedef struct Noeud *Arbre;
 
int initialiserArbre(Arbre *arbre);
int ajouter(Arbre *arbre, char *mot);
int placerNoeud(Noeud *noeudArbre, Noeud *noeud);
void afficherArbre(Arbre *arbre );
void parcourirArbre(Noeud *noeud);

Voici ensuite la fonction Ajouter. Celle-ci à pour but de créer un nouveau Noeud contenant un mot et d'ajouter ce Noeud à l'arbre :

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
 
 int ajouter(Arbre *arbre, char *mot){
  9 
 10         Noeud *noeud;
 11 
 12         if((noeud = (Noeud *) malloc(sizeof(Noeud))) == NULL){
 13                 perror("erreur dans l'allocation du noeud \n");
 14                 return -1;
 15         }
 16 
 17         if((noeud->mot = (char *) malloc(strlen(mot) * sizeof(char))) == NULL){
 18                 perror("erreur dans l'allocation de la string \n");
 19                 return -1;
 20         }
 21 
 22         strcpy(noeud->mot, mot);
 23         noeud->cpt = 0;
 24         noeud->filsGauche = NULL;
 25         noeud->filsDroit = NULL;
 26 
 27         if(*arbre == NULL){
 28                 *arbre = noeud;
 29                 return 1;
 30         }else{
                 if(strcmp(noeud->mot,(*arbre)->mot) > 0){
 32                         placerNoeud((*arbre)->filsDroit, noeud);
 33                         printf("adresse du noeud : %p \n", (*arbre)->filsDroit);
 34                 }else{
 35                         placerNoeud((*arbre)->filsGauche, noeud);
 36                         printf("adresse du noeud : %p \n", (*arbre)->filsDroit);
 37                 }
 38         }
 39 
 40 }

Cette fonction appelle à la fin la fonction placerNoeud qui va s'occuper de placer le Noeud :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 int placerNoeud(Noeud *noeudArbre, Noeud *noeud){
 43         printf("dans placerNoeud \n");
 44         printf("%s \n", noeud->mot);
 45         printf("%p \n", noeud);
 46         if(noeudArbre == NULL){
 47                 printf("adresse de noeudArbre : %p\n", noeudArbre);
 48                 noeudArbre = noeud;
 49                 printf("adresse de noeudArbre après : %p\n", noeudArbre);
 50                 printf("noeudArbre :  %s \n", noeudArbre->mot);
 51                 return 1;
 52         }

Je ne poste que ce morceau de code, le reste n'étant qu'un appel récursif.

Mon problème est le suivant :

Lors du placement du premier Noeud, celui-ci est bien sauvegardé. Ensuite, lors de la création d'un nouveau Noeud, mon programme va jusqu'à l'appel de la fonction PlacerNoeud et passe en paramètre le filsDroit où le filsGauche du noeud racine, la valeur de ce noeud étant évidement null. Lorsque je rentre dans le if de la fonction PlacerNoeud, la valeur de noeudArbre vaut bien null, ensuite l'instruction noeudArbre = noeud fonctionne sans soucis car l'adresse mémoire de noeudArbre est par après équivalente à celle de noeud et l'affichage du mot se fait sans problème.

Mais, lorsque je retourne dans la fonction ajouter, et que je vérifie l'adresse mémoire du fils qui avait été passé en paramètre, celle-ci vaut à nouveau null! C'est comme ci l'assignation ne valait que tant que je reste dans la méthode PlacerNoeud! J'avoue ne pas comprendre d'où vient mon erreur.

Voici un exemple de run avec les printf, celà sera peut être plus parlant :

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
 
 
baton /* Je rentre le mot */ 
 
 
zob
dans placerNoeud /* indique dans quelle méthode je suis */ 
zob
 
0x135c060 /* adresse mémoire du noeud à ajouter */ 
adresse de noeudArbre : (nil) /* adresse mémoire du fils */
adresse de noeudArbre après : 0x135c060 /* nouvelle adresse mémoire du fils */
noeudArbre :  zob /* affichage du mot à partir du fils */
 
adresse du noeud : (nil) /* de retour dans la méthode appelante, l'adresse mémoire du fils vaut de nouveau null */

En vous remerciant par avance!

[foetus]

Erreur de débutant niveau 0

Le passage en C est par valeur.

Dans ton cas, une variable temporaire va être créée pour stocker la valeur de noeudArbre, modifiée et ensuite ... détruite.
Résultat: noeudArbre n'a pas été modifiée.
Solution: un double pointeur

int placerNoeud(Noeud** noeudArbre, Noeud* noeud)

[Braise]

Tout d'abord, un grand merci, j'ai modifié le code et cela fonctionne sans soucis.

Mais j'aimerais si possible quelques éclaircissements

Code :

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

1
2
 
 placerNoeud((*arbre)->filsDroit, noeud);

Ce que je ne comprend pas, c'est qu'il me semblait qu'en faisant (*arbre)->filsDroit , je passais en paramètre le pointeur sur le noeud (pour rappel, les structures sont définies comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
typedef struct Noeud {
 
        char *mot;
        int cpt;
        struct Noeud *filsGauche;
        struct Noeud *filsDroit;
 
}Noeud;
 
typedef struct Noeud *Arbre;

)

Et que donc, dans la fonction, lorsque j'utilisais noeudArbre, j'avais l'adresse mémoire et noeudArbre->mot me donnait accès à la "valeur" du mot.

Or, si je comprend bien, ce que je faisais c'est que je passais une valeur en paramètre et non pas un pointeur, c'est ça?

Je me doute que c'est très brouillont, mais j'ai du mal à visualiser ce que je faisais.

[foetus]

Non c'est confusant parce que tu passais la valeur de ta variable pointeur (donc une adresse) et non le pointeur de cette variable (*) (donc l'adresse de la dite variable pointeur, soit un pointeur de pointeur)

* -> parce que tu veux la modifier

Maintenant si c'était un entier au lieu d'un pointeur, cela est plus clair
Non c'est confusant parce que tu passais la valeur de ta variable int (donc un nombre) et non le pointeur de cette variable (*) (donc l'adresse de la dite variable int, soit un pointeur de int)

[Médinoc]

Le problème, c'est qu'il faut parfois modifier le pointeur lui-même et non seulement la valeur pointée.
Et pour cela, il faut passer un pointeur vers le pointeur.

Edit: Oups, devancé par foetus

[Braise]

Ca commence à s'éclaircir!

Donc, si je résume, lorsque je veux modifier la valeur d'un pointeur, un * est suffisant.

Cependant, si je cherche à modifier le pointeur lui même, dans mon cas l'adresse de celui-ci, alors j'ai besoin d'un pointeur de pointeur (un **).

En tout cas, un grand merci pour les explications!

[Matt_Houston]

C'est cela.

Un pointeur, ce n'est finalement qu'une variable de type entier dédiée au stockage d'une adresse. Pour altérer sa valeur via une fonction et voir cette modification répercutée dans la portée du bloc appelant, tu dois donc passer sa propre adresse en ajoutant un * à son type comme tu le ferais avec une variable d'un type « non-pointeur ».