Probléme de compréhension avec les pointeurs

Bonjour,

j'ai trouve sur le site le code d'une fonction qui permet de réaliser l'échange de pointeurs mais je n'arrive pas à comprendre son fonctionnement. En effet, je me perds dans la signification des pointeurs. J'ai du mal à comprendre la signification du pointeur générique void * et encore plus de *(void **)d1. Pourquoi avoir placé deux opérateurs de déférencence aprés le void?

Code:

---

1 2 3 4 5 6 7 8

void swap( void * d1 , void * d2 ) { void * tmp; tmp = *(void **)d1; *(void **)d1 = *(void **)d2; *(void **)d2 = tmp; }

---

Merci beaucoup pour votre aide et pour vos réponses.

Salut,

void * est un pointeur générique. Il permet de stocker l'adresse d'une variable sans s'intéresser au type de la variable en question.

Il est interdit de déréférencer un pointeur void *. La ligne suivante:

Code:

---

tmp = *(void **)d1;

---

te permet de stocker la valeur située à l'adresse pointée par d1 en tromper le compilateur. On lui dit: "Je veux traiter d1 comme un pointeur-sur-pointeur-sur void", puis on déréférence d1 pour accéder à la valeur et la stocker dans tmp.

Personnelement, je ne trouve cette façon de faire pas propre du tout, et je la déconseille. En plus, si l'auteur a voulu une fonction swap générique, c'est raté, car cela ne fonctionne qui si le type de la variable pointée a la même taille qu'un pointeur: dès lors, mieux vaut faire:

Code:

---

1 2 3 4 5 6 7

swap_int(int *d1, int *d2) { int tmp; tmp = *d1; *d1 = *d2; *d2 = tmp; }

---

ou

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

void swap(void *d1, void *d2, char const *type) { if (!(strcmp(type, "int")) { int tmp; tmp = *(int*)d1; *(int*)d1 = *(int*)d2; *(int*)d2 = tmp; } else if (!strcmp(type, "double") { /* ... */ } /* ... */ }

---

Thierry

Ce tutoriel http://rperrot.developpez.com/articles/c/genericite/ propose une solution générique intéressante:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int swap_generic(void *const a, void *const b, size_t size) { void *const temp = malloc(size);   if ( temp == NULL ) return EXIT_FAILURE;   memcpy(temp, a, size); memcpy(a, b, size); memcpy(b, temp, size);   free(temp);   return EXIT_SUCCESS; }

---

Voici un exemple d'utilisation:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

int main(void) { int i1 = 10; int i2 = 100; double d1 = 10.562; double d2 = 100.9978;   /* On échange les deux valeurs de type int*/ printf("AVANT: i1 = %d\ti2 = %d\n", i1, i2); swap_generic(&i1, &i2, sizeof i1); printf("APRES: i1 = %d\ti2 = %d\n", i1, i2);   /* On échange les deux valeurs de type double*/ printf("AVANT: d1 = %f\td2 = %f\n", d1, d2); swap_generic(&d1, &d2, sizeof d1); printf("APRES: d1 = %f\td2 = %f\n", d1, d2);   return EXIT_SUCCESS; }

---

Thierry

Citation:

---

Envoyé par *air*

j'ai trouve sur le site le code d'une fonction qui permet de réaliser l'échange de pointeurs mais je n'arrive pas à comprendre son fonctionnement.

---

Normal, c'est codé avec les pieds... Il est extrêmement facile d'écrire du code illisible en C. Il est beaucoup plus utile d'écrire du code lisible...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void pswap (void *p1, void *p2) { void **pp1 = p1; /* adresses des pointeurs */ void **pp2 = p2; void *ptmp = *pp1; /* echange (temporaire) */ *pp1 = *pp2; *pp2 = ptmp; }   #include <stdio.h>   int main (void) { char const *pa = "hello"; char const *pb = "world";   printf ("%s %s\n", pa, pb); pswap (&pa, &pb); printf ("%s %s\n", pa, pb); return 0; }

---

Citation:

---

Envoyé par mujigka

En plus, si l'auteur a voulu une fonction swap générique<...>

---

Ben non:

Citation:

---

Envoyé par P.O.

fonction qui permet de réaliser l'échange de pointeurs

---

Citation:

---

Envoyé par Emmanuel Delahaye

Ben non:
Citation:
P.O. a écrit :
fonction qui permet de réaliser l'échange de pointeurs

---

Autant pour moi! Dans le cas de l'échange de pointeur, il n'y a aucun soucis avec le code présenté. C'est moi qui ai tout compris de travers (enfin presque tout).

Thierry

Tout d'abord merci pour vos réponses. Elles m'ont éclairé sur quelques points.

Code:

---

1 2 3 4 5 6 7 8

void swap( void * d1 , void * d2 ) { void * tmp; tmp = *(void **)d1; *(void **)d1 = *(void **)d2; *(void **)d2 = tmp; }

---

Je ne comprend pas tres bien ce que veut dire mujigka par :

Citation:

---

Je veux traiter d1 comme un pointeur-sur-pointeur-sur void, puis on déréférence d1 pour accéder à la valeur et la stocker dans tmp.

---

En effet, pour moi l'expression void *d1 est equivalente à (void **)d1 cad d1 est un pointeur sur un "type void".

D

void* est un type de pointeur générique, on peut mettre n'importe quoi dedans.
Ainsi, lors de l'appel:

Code:

---

1 2 3 4

char const *pa = "hello"; char const *pb = "world";   pswap (&pa, &pb);

---

On passe des char const * * implicitement transtypés en void*.

Une fois dans la fonction, on a besoin du niveau d'indirection qu'on avait supprimé dans le void *, ainsi on fait ceci:

Code:

---

1 2 3 4

void pswap (void *p1, void *p2) { void **pp1 = p1; /* adresses des pointeurs */ void **pp2 = p2;

---

Ainsi, pp1 et pp2 sont bien des pointeurs vers pointeurs, comme le sont les paramètres réels.
On peut alors utiliser pp1 et pp2 pour faire l'échange des pointeurs.

Citation:

---

Envoyé par *air*

Je ne comprend pas tres bien ce que veut dire mujigka par :

Citation:

---

Envoyé par mujigka

Je veux traiter d1 comme un pointeur-sur-pointeur-sur void, puis on déréférence d1 pour accéder à la valeur et la stocker dans tmp.

---

En effet, pour moi l'expression void *d1 est equivalente à (void **)d1 cad d1 est un pointeur sur un "type void".

---

Une grande partie de ce que j'ai dit est dû à ma mauvaise compréhension de ta question (je n'avais pas compris que tu désirais faire un swap de pointeurs). Ainsi, dans le cadre de l'échanche de pointeurs, la fonction

Code:

---

1 2 3 4 5 6 7

void pswap( void * pd1 , void * pd2 ) { void * p_tmp; p_tmp = *(void **)pd1; *(void **)pd1 = *(void **)pd2; *(void **)pd2 = p_tmp; }

---

fait bien le job qu'elle est sensée faire.

Ici, l'instruction:

Code:

---

void *p_tmp = *(void**)pd1;

---

est équivalente aux instructions:

Code:

---

1 2	void **ppd1 = (void**)pd1; void *p_tmp = *ppd1;

---

Il faut comprendre ici que le type void* n'est pas équivalent à void**, car tu ne peux pas écrire *pd1 (i.e. tu peux pas déréférencer pd1, car tu ne connais pas le type de la valeur contenue à cette adresse) mais tu peux écrire *ppd1 (i.e. tu peux déréférencer ppd1, car tu sais que la valeur contenue à cette adresse est un pointeur).

Thierry

Citation:

---

Envoyé par Médinoc

On passe des char const * * implicitement transtypés en void*.
Une fois dans la fonction, on a besoin du niveau d'indirection qu'on avait supprimé dans le void *.

---

Dans l'exemple que tu as donné pour moi on passe dans la fonction un pointeur de type char const transtypé en void. Je ne comprend pas pourquoi tu mets deux opérateurs d'indirection aprés char const car pour moi l'expression char const *pa signifie pa est un pointeur de type char const.
Je m'excuse :oops: mais je n'arrive pas à suivre ton raisonnement qui améne au fait que pp1 par exemple est un pointeur de pointeur.

pswap(&pa, (&pb);

Citation:

---

Envoyé par mujigka

Il faut comprendre ici que le type void* n'est pas équivalent à void**, car tu ne peux pas écrire *pd1 (i.e. tu peux pas déréférencer pd1, car tu ne connais pas le type de la valeur contenue à cette adresse) mais tu peux écrire *ppd1 (i.e. tu peux déréférencer ppd1, car tu sais que la valeur contenue à cette adresse est un pointeur).

---

Par exemple dans l'exemple suivant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <stdio.h>   void pswap( void *d1 , void *d2 );   main() { int pa=1, pb=2;   printf ("%d %d\n", pa, pb); pswap (&pa, &pb); printf ("%d %d\n", pa, pb); }   void pswap( void *pd1 , void *pd2 ) { void * tmp; tmp = *(void **)pd1; *(void **)pd1 = *(void **)pd2; *(void **)pd2 = tmp; }

---

La par exemple on s'est que pd1=&pa donc *pd1 contient la valeur de pa et donc son type. Désolé :oops: mais je ne comprend pas le raisonnement qui t'améne au pointeur de pointeur.Je me perd surement dans la notion de déférencement.

• Pour échanger deux int dans une fonction, on a besoin de passer deux pointeurs de int en paramètre.
  
  Code:

  ---

  1 2 3 4 5 6

  void intswap(int *p1, int *p2) { int tmp = *p1; *p1 = *p2; *p2 = tmp; }

  ---

• Pour échanger deux pointeurs dans une fonction, on a besoin de passer deux pointeurs de pointeur en paramètre.
  
  Code:

  ---

  1 2 3 4 5 6

  void ptrswap(TYPE **pp1, TYPE **pp2) { TYPE *pTmp = *pp1; *pp1 = *pp2; *pp2 = pTmp; }

  ---

  Sauf qu'ici, on veut une fonction générique, donc plutôt que de faire une fonction pour chaque type de pointeur (char*, int *, etc.), on les passe directement sous forme de void* et en interne, on les convertit en pointeurs de void*...

Oui d'accord mais par rapport à ma fonction.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <stdio.h>   void pswap( void *d1 , void *d2 );   main() { int pa=1, pb=2;   printf ("%d %d\n", pa, pb); pswap (&pa, &pb); printf ("%d %d\n", pa, pb); }   void pswap( void *pd1 , void *pd2 ) { void * tmp; tmp = *(void **)pd1; *(void **)pd1 = *(void **)pd2; *(void **)pd2 = tmp; }

---

La en paramétre on a deux pointeurs de type "void" et non des pointeurs de pointeurs comme tu as montré dans l'exemple. Ce que j'arrive pas à comprendre c'est le raisonnement qui améne à des pointeurs de pointeur. Par exemple, dans la citation de

Code:

---

1 2 3 4

mujigka a écrit :   Il faut comprendre ici que le type void* n'est pas équivalent à void**, car tu ne peux pas écrire *pd1 (i.e. tu peux pas déréférencer pd1, car tu ne connais pas le type de la valeur contenue à cette adresse) mais tu peux écrire *ppd1 (i.e. tu peux déréférencer ppd1, car tu sais que la valeur contenue à cette adresse est un pointeur).

---

Le type de pd1 tu le connais car tu sais que pd1=&pa donc *pd1 à la valeur de pa. En gros je suis perdu désolé!!! Je comprends pas l'histoire de déférencement qu'essaye de m'expliquer mujigka

Citation:

---

Envoyé par *air*

Par exemple dans l'exemple suivant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <stdio.h>   void pswap( void *d1 , void *d2 );   main() { int pa=1, pb=2;   printf ("%d %d\n", pa, pb); pswap (&pa, &pb); printf ("%d %d\n", pa, pb); }   void pswap( void *pd1 , void *pd2 ) { void * tmp; tmp = *(void **)pd1; *(void **)pd1 = *(void **)pd2; *(void **)pd2 = tmp; }

---

La par exemple on s'est que pd1=&pa donc *pd1 contient la valeur de pa et donc son type. Désolé :oops: mais je ne comprend pas le raisonnement qui t'améne au pointeur de pointeur.Je me perd surement dans la notion de déférencement.

---

NON! Parce que là, tu cherches à échanger des entiers. pa et pb, comme leur non ne l'indique pas, ne sont pas des pointeurs, mais des entiers de type int, et tu peux utiliser la fonction swap_int donnée plus haut pour échanger leurs valeurs. Comme je l'ai expliqué dans mon premier post, il est exclut d'utiliser la fonction appelée ici pswap pour échanger autre chose que des pointeurs.


Thierry

Je suis d'accord sur le fait que pa et pb ne soient pas des pointeurs. Pourtant lorque j'execute le programme la valeur de pa s'echange bien avec pb 8O! Pourquoi?


Ps Merci pour votre patience. Les pointeurs c'est ma passion lol:

Parce qu'il se trouve que sur ta machine (comme sur la mienne d'ailleurs), une variable de type int et un pointeur ont la même taille (chez moi: 32 bits).

La fonction pswap() échange les valeurs situées aux adresses pointées par d1 et d2. La fonction pswap() suppose que ces valeurs sont des pointeurs, et les échange. Comme un int et un pointeur ont la même taille, cela ne fait pas de différence. Si tu fais maintenant cette expérience en essayant d'échanger deux variables de type double à l'aide de la fonction pswap(), tu va avoir quelques surprises.

Si tu désires échanger deux valeurs de type int, pswap() n'est pas la bonne stratégie (pas portable, car tu supposes qu'un int a la même taille mémoire qu'un pointeur). Utiliser les fonctions swap_int() et swap_generic() données dans mes deux premiers posts.

Si tu désires échanger la valeurs de pointeurs: pswap() convient.

Thierry

Citation:

---

Envoyé par *air*

La en paramétre on a deux pointeurs de type "void" et non des pointeurs de pointeurs comme tu as montré dans l'exemple. Ce que j'arrive pas à comprendre c'est le raisonnement qui améne à des pointeurs de pointeur. Par exemple, dans la citation de

---

Je pense que ton problème de compréhension vient de là. La notation "void *" ne veut pas dire "pointeur de type void" mais plûtot "pointeur générique".
En d'autre termes cela veut dire que c'est un pointeur qui pointe vers n'importe quel type d'objet et entre autre vers un pointeur (comme dans les exemples cités dans le posts précédents).