Discussion :

[*air*]

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 :

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

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.

[Thierry Chappuis]

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 :

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

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 :

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

1
2
3
4
5
6
7
swap_int(int *d1, int *d2)
{
    int tmp;
    tmp = *d1;
    *d1 = *d2;
    *d2 = tmp;
}

ou

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

[Thierry Chappuis]

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

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

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

[Emmanuel Delahaye]

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 :

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

[Emmanuel Delahaye]

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

Ben non:

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

[Thierry Chappuis]

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

[*air*]

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

Code :

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

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 :

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

[Médinoc]

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

Code :

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

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 :

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

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.

[Thierry Chappuis]

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

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 :

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

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 :

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

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

est équivalente aux instructions:

Code :

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

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

[*air*]

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 mais je n'arrive pas à suivre ton raisonnement qui améne au fait que pp1 par exemple est un pointeur de pointeur.

[Médinoc]

pswap(&pa, (&pb);

[*air*]

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 :

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

[Médinoc]

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

  Code :

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

  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 :

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

  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*...

[*air*]

Oui d'accord mais par rapport à ma fonction.

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

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

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

[Thierry Chappuis]

Par exemple dans l'exemple suivant:

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

[*air*]

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 ! Pourquoi?


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

[Thierry Chappuis]

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

[crocodilex]

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).