Discussion :

[tanguy.L]

Bonjour a tous,

tout d'abord je precise que je suis un debutant total en C. (Bon j'ai regarde des tutos, mais c'est pas encore ca...)

Bref je suis en train de regarder un bout de code la et vraiment je ne comprend pas ce que ca veut dire...

Une fonction prend en argument un parametre Value de type void*
Il s'agit donc d'un pointeur de type non defini.

Dans le corps de ma fonction il y a une ligne etrange :

Code :

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

1
2
 
maVariable = * (void **) Value;

Avec maVariable qui est de type void*

donc en gros rien de bien complique appriori, on veut refiler une reference de Value a une autre classe. Mais il y a un drole de truc au milieu de tout ca

Code :

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

(void **)

Ca ressemble a un cast, mais le type void** je connais pas... Et en plus je ne vois pas l'interet de cet ajout.

Pouvez vous m'expliquer s'il vous plait?
Merci beaucoup.

[ram-0000]

void **, c'est un pointeur de pointeur sur void.

C'est marrant, mais j'ai l'impression que le bout de code que tu présentes s'écrit plus simplement coimme cela (ou alors j'ai tout faux ) :

Code :

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

maVariable = (void *) Value;

[jeroman]

Si on tape ce code :

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 fonction ( void * Value )
{
	void * maVariable ;
 
	maVariable = * (void **) Value ;
 
	printf ( "valeur 'Value' : %p\n" , Value ) ;
	printf ( "valeur 'maVariable' : %p\n" , maVariable ) ;
}
 
int main(void)
{
	int i = 257 ;
 
	fonction ( &i ) ;
 
	system ( "pause" ) ;
	return 0;
}

on remarque que 'maVariable' (pointeur sur void) prend comme valeur la valeur (de type int) située à l'adresse pointée par 'Value'.
Dans mon exemple, on passe à la fonction l'adresse de l'entier 'i' valant 257, et au final le pointeur 'maVariable' se retrouve avec la même valeur que cet entier (0x00000101 = 257). Par contre, si on pointe à cette adresse 257, cela a toutes les chances de planter. Donc, personnellement, je ne vois pas l'intérêt d'un tel code. Qu'est censé faire ce code que tu as trouvé ? Après, ça dépend du contexte. C'est de l'embarqué ?

Sinon,

Code :

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

maVariable = * (void **) Value ;

est en principe équivalent à :

Code :

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

maVariable = (void*) * (int*) Value ;

(si on considère qu'un int a la même taille qu'un pointeur, ce qui -je crois- est toujours vrai. A vérifier quand même dans la norme...).

[ram-0000]

(si on considère qu'un int a la même taille qu'un pointeur, ce qui -je crois- est toujours vrai. A vérifier quand même dans la norme...).

Sur une architecture 32 bits ou 64 bits, c'est vrai mais sur une archi 8 ou 16 bits, c'est faux.

Il me semble me rappeler que la taille d'un int est liée à la taille du bus de données sur la CPU.

[diogene]

1- Une adresse A de type void* est l'adresse d'un objet dont le type n'est pas spécifié. La conséquence est qu'on ne peut déréférencer cette adresse pour obtenir l'objet, donc écrire *A, qui serait un objet de type inconnu donc de taille et de propriétés inconnus. Avant de pouvoir déréférencer A, il faut rétablir le type correct de l'objet dont A est l'adresse, en d'autres termes caster A (et ne pas se tromper de type).

2- Une adresse A du type void** est quelque chose de beaucoup plus banal que void* : c'est l'adresse d'un pointeur sur void*. Le type de l'objet référencé par cette adresse est donc parfaitement connu : c'est un pointeur sur void. Il est possible d'écrire sans problème *A (c'est une adresse de type void*). Par contre, *A doit être casté avant de pouvoir être déréférencé comme évoqué en (1) et on ne peut écrire **A.

3- En appliquant ceci, Value est du type void* et est casté en void** pour pouvoir être déréférencé :
(void**) Value
puis déréférencé
*(void**) Value
et le résultat est une adresse de type void* qui est stocké dans maVariable . Comme dans le cas présent maVariable est de type void*, plus tard, pour le déférérencer, il faudra au préalable caster sa valeur.

ram-0000 :
C'est marrant, mais j'ai l'impression que le bout de code que tu présentes s'écrit plus simplement coimme cela (ou alors j'ai tout faux ) :

Code :

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

maVariable = (void *) Value;

Non, ce n'est pas la même chose : La valeur de maVariable ne sera pas la même.

[ram-0000]

C'est marrant, mais j'ai l'impression que le bout de code que tu présentes s'écrit plus simplement coimme cela (ou alors j'ai tout faux ) :

Code :

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

maVariable = (void *) Value;

Non, ce n'est pas la même chose : La valeur de maVariable ne sera pas la même.

Tu as raison, ce n'est pas pareil.

[tanguy.L]

merci beaucoup pour ses ecplications!

[diogene]

jeroman :

Ton exemple est typique d'un cast abusif, donc donnant un résultat qui parait incohérent :
Le cast (void **) Value est faux : Value n'est pas l'adresse d'un void * (d'une adresse) mais l'adresse d'un int. Si le cast est faux, le résultat est faux.
L'expression

Code :

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

maVariable = (void*) * (int*) Value ;

n'a aucun rapport avec

Code :

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

maVariable = * (void **) Value ;

si on considère qu'un int a la même taille qu'un pointeur, ce qui -je crois- est toujours vrai. A vérifier quand même dans la norme...).

Il n'y a aucun rapport entre entier et pointeur : ce sont deux concepts radicalement différents. La taille d'un int est liée à l'unité de calcul de la machine (donc aux données), celle d'un pointeur à l'espace mémoire adressable. D'ailleurs, même leur arithmétique est différente. La confusion ou l'assimilation pointeurs/entiers ne peut qu'engendrer des problèmes