Discussion :

[Lanslow]

Bien le bonjour/bonsoir,

Je dispose de deux fonctions, que je vais vous donner ci-dessous :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
object_list * List_Cons(object * O, object_list * pHead)
{
 
  /* allocation of a new cell in the heap */
  object_list * pNew = malloc(sizeof(object_list));
  pNew->obj = O; /* equivalent to (*new).object = p; */
  pNew->pNext = NULL;
 
  pNew->pNext = pHead;
  return pNew; 
}

et :

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
void Remove(object_list ** ppHead, object * O)
{
  object_list * pH = *ppHead;
  if (pH->obj == O)
    {
      *ppHead = pH->pNext;
      free(pH);
      return;
    }
 
  while (pH->pNext->obj != O)
    {
      pH = pH->pNext;
    }
  object_list * tmp = pH->pNext;
  pH->pNext = pH->pNext->pNext;
  free(tmp);
}

Dans la première, la valeur retournée est de type object_list *, donc un simple pointeur sur une structure de liste simplement chaînée.
Dans la seconde, la valeur prise en paramètre est de type object_list **.

Je souhaiterai utiliser la valeur retournée dans la première, dans la seconde. De quelle façon procéder, puisqu'elles ne sont pas de même type.

Merci d'avance de vos réponses!

Cordialement.

[foetus]

Code :

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

1
2
3
4
5
6
7
8
    object dummy;
    object_list* head;
 
    head = List_Cons(&dummy, head);
 
//  ....
 
    Remove(&head, &dummy);

[Lanslow]

Super merci !

[Lanslow]

Le & sur un pointeur équivaut à un pointeur de pointeur? Il ne faut pas initialisé le pointeur sur head pour que ce soit véritablement un pointeur de pointeur?

[foetus]

Je ne sais pas trop quoi te dire ... peut-être que c'est une gymnastique de développeur et qu'il faut pratiquer

• Un pointeur est une variable qui contient l’adresse d'une autre variable (elle pointe vers)
• Un pointeur permet l'allocation de données sur le tas (heap) et non pas sur la pile (stack)
• Le passage de paramètres en C est un passage par copie. Donc pour modifier un paramètre on passe un pointeur
• Mais un pointeur en paramètre, on peut modifier sa valeur pointée mais pas le pointeur lui-même.
• Pour modifier un pointeur soit on le retourne (ta fonction List_Cons) soit on passe un double-pointeur (l'adresse de ce pointeur) (ta procédure Remove)

[Lanslow]

D'accord, merci beaucoup de ta réponse!

[Sve@r]

Code :

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

1
2
3
4
void Remove(object_list ** ppHead, object * O)
{
    ...
}

Hé oui. Parce que tu n'as pas créé de type dédié à ta liste, tu te retrouves obligé de créer une fonction recevant un pointeur de pointeur.

Je m'explique: généralement, une liste se définit par un simple noeud qui contient l'adresse du noeud suivant. Et pour tenir la liste, il suffit juste de récupérer l'adresse du premier noeud. Mais si on doit faire modifier cette adresse par une fonction, celle-ci doit alors recevoir l'adresse de cette adresse et la stocker dans un "<type> **".

Or si on pense aussi à définir un type dédié à la liste elle-même, ce type (qui, lui, stockera ce premier noeud) devient un simple type et si on doit le faire modifier par une fonction, il suffit de lui passer un simple pointeur qu'on stockera dans un simple "<type> *"...

Démo:

Code c :

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
typedef struct s_noeud {
    int valeur;
    struct s_noeud *next;
} t_noeud;
 
typedef struct {
    t_noeud *tete;
} t_liste;
 
void init_liste(t_liste *l)
{
    l->tete=NULL;
}
 
void affiche_liste(t_liste *l)
{
    printf("Affichage de ma liste\n");
    if (l->tete == NULL) {
        printf("Liste vide\n");
        return;
    }
 
    t_noeud *pt;
    int i;
    for (pt=l->tete, i=1; *pt; pt=pt->next, i++)
        printf("Valeur noeud %d: %d\n", i, pt->valeur);
}
 
int main()
{
    t_liste liste;
    init_liste(&liste);
    affiche_liste(&liste);
}

Outre la simplification de programmation (manipuler des "<type>*" reste plus simple que des "<type> **"), cela apporte aussi l'avantage d'être facilement évolutif. Si tu veux rajouter par exemple un compteur d'éléments, tu le rajoutes simplement dans ton t_liste. Toutes les fonctions recevant alors ce t_liste y auront alors immédiatement accès...

Code c :

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
typedef struct {
    t_noeud *tete;
    int tot;
} t_liste;

void affiche_liste(t_liste *l)
{
    printf("Affichage de ma liste\n");
    if (l->tete == NULL) {
        printf("Liste vide\n");
        return;
    }

    t_noeud *pt;
    int i;
    for (pt=l->tete, i=1; *pt; pt=pt->next, i++)
        printf("Valeur noeud %d/%d: %d\n", i, l->tot, pt->valeur);
}