Discussion :

[_concept_]

Bonjour,
je n'ai pas d'exemple sous la main pour mieux faire comprendre mon problème (c'est dommage...) mais j'ai du mal à comprendre le passage en paramètre de pointeur sur pointeur.
Par exemple on a un pointeur et pour modifier se valeur (ou celle pointé par celui-ci je sais pas) je vois parfois qu'il faut passer par un pointeur de pointeur et je ne saisi pas pourquoi.

Code :

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

1
2
3
4
5
6
7
8
9
fonction_1(&pointeur);
...
void fonction_1(int **pt)
 
/* au lieu de */
 
fonction_2( pointeur);
...
void fonction_2(int *pt)

Pareil pour les matrices :

Code :

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

1
2
3
4
5
6
7
8
9
fonction_1(&matrice);
...
void fonction_1(int *((*mat)[N])) /* je crois */
 
/* au lieu de */
 
fonction_2( matrice);
...
void fonction_2(int (*mat)[N])

Merci de vos réponses.

[ram-0000]

Le meilleur exemple que je voie de l'usage d'un pointeur de pointeur, c'est dans l'utilisation d'une fonction d'allocation mémoire.

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
void main(void)
{
   char *pointeur;
   if(MonMalloc(&pointeur, 12) == 1)
   {
      /* erreur d'allocation */
   }
}
 
MonFree(&pointer);
 
int MonMalloc(void **Pointer, int Size)
{
   /* alloue un pointeur */
   *Pointer = malloc(Size);
   if(*Pointer == NULL)
      return 1;
 
   return 0;
}
 
int MonFree(void **Pointer)
{
   free(*Pointer);
   *Pointer = NULL;
}

Dans cet exemple (qui n'est pas complet), on est obligé d'utiliser un pointeur de pointeur dans le paramètre de la fonction pour que l'appelant puisse récupérer le pointeur alloué.

Pour la fonction MonFree, le fait d'utiliser un pointeur de pointeur permet de liberer le pointeur et en plus de le réinitialiser de manière à ce qu'il ne soit plus utilisable dans le code.

[_concept_]

Mais pourquoi ne fait on pas ceci ?

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
 
#include <stdio.h>
 
int MonMalloc(char *Pointer, int Size)
{
   /* alloue un pointeur */
   Pointer = malloc(Size);
   if(Pointer == NULL)
      return 1;
 
   return 0;
}
 
void MonFree(char *Pointer)
{
   free(Pointer);
   Pointer = NULL;
}
 
int main(void)
{
   char *pointeur = NULL;
   if(MonMalloc(pointeur, 12) == 1)
   {
     return -1;
   }
   MonFree(pointeur);
 
   return 0;
}

[ram-0000]

Code :

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

1
2
char *pointeur = NULL;
   if(MonMalloc(pointeur, 12) == 1)

Dans ce cas, le contenu du pointeur est passé par valeur, ce contenu est modifié par la fonction et en quittant la fonction le contenu modifié est perdu.

[nbenbourahla]

Bonjour
On peux pas faire ce que tu as car dans ton code tu declare un pointeur char *pointeur = NULL;
Mais si tu le passe a ta fonction MonMalloc de cette facon :
MonMalloc(pointeur, 12)
Ce n'est pas ton pointeur que tu as passer mais une copie (ce qui s'appelle un passage par copie ) et donc dans ta fonction mon malloc c'est ton pointeur que tu malloc mais une copie qui serra detruite a la sortie de la fonction donc ton pointeur ne serra jamais alloué c'est pour sa que le meilleur chose a faire et de passe MonMalloc(&pointeur, 12) (Donc un passage par reference et dans ce cas la c bien ton pointeur que tu modifie et pas une copie)

de rien

[diogene]

Par exemple on a un pointeur et pour modifier se valeur (ou celle pointé par celui-ci je sais pas) je vois parfois qu'il faut passer par un pointeur de pointeur et je ne saisi pas pourquoi.

Ce n'est pas particulier aux pointeurs : si je veux qu'une fonction puisse modifier une grandeur par la liste des paramètres , je dois passer son adresse. Si la fonction connait l'adresse de la grandeur, elle sait où celle-ci est située en mémoire et peut donc y accéder pour la modifier. C'est vrai que la grandeur soit un pointeur ou autre chose.

Code :

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

1
2
3
4
5
6
7
void fonction_1(int **pt);
void fonction_2(int *pt);
...
int I;
int * pointeur = &I ;
fonction_1(&pointeur); // peut modifier pointeur (et I)
fonction_2( pointeur); // ne peut modifier pointeur mais peut modifier I ;

Ce n'est pas la seule raison pour laquelle un paramètre du type int ** peut figurer dans la liste des paramètres. Un autre cas courant est le passage à la fonction d'un tableau de pointeur sur int :

Code :

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

1
2
3
4
void fonction_3(int ** tab);
...
int * Tab[10];
fonction_3(Tab);

Code :

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

1
2
void fonction_4(int (*mat)[N]);
fonction_4( matrice);

matrice doit donc être dans ce cas un tableau du type int Tab[...][N] et le paramètre est du type "adresse d'un élément du tableau", comme pour tout tableau. Les éléments du tableau sont ici des tableaux de N int et le type du paramètre doit être "adresse d'un tableau de N int" : int (*) [N] (à différentier de int * [N] : tableau de pointeurs sur int)

Code :

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

1
2
void fonction_5(int *((*mat)[N]));
fonction_5(&matrice);

ne correspond pas à matrice avec le même type que ci-dessus mais à int * matrice[N] (de même que void fonction_5(int *(*mat)[N]);

[_concept_]

Code :

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

// ne peut modifier pointeur mais peut modifier I ;

Ceci explique tout.
Donc si je veux modifier la valeur d'une matrice dans une fonction ceci convient :

Code :

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

1
2
3
modif(matrice);
...
void modif(int (*mat)[N])

?