Conversion void* et double

Version imprimable

20/04/2007, 15h00
EnigmuS

Conversion void* et double

Bonjour,

pourquoi en C on ne peut pas convertir un void* en double je croyais que le type void etait le type générique ?

merci d'avance.
20/04/2007, 15h06
Gruik

Salut,

void * est le type de pointeur générique, pas le type générique. Tu peux caster un "void *" en "double *" mais pas en "double".
Le type void tout court n'a pas de sens, à part dans les signatures de fonction.
20/04/2007, 15h06
Médinoc

void* est un pointeur générique, mais reste un pointeur.
double, c'est un nombre.

Edit: Non seulement je me fais griller, mais en plus je dis des conneries...
20/04/2007, 15h10
Thierry Chappuis

Citation:

Envoyé par Médinoc

void* est un pointeur générique, mais reste un pointeur.
double, c'est un entier.

Tu a voulu dire nombre à virgule flottante...

Thierry
20/04/2007, 15h13
EnigmuS

ah ok merci et pourquoi ca ca marche :

tabgen[i]= (long *)(atol(tabE[i]));

et pas ca :

tabgen[i]= (double *)(atof(tabE[i]));

avec tabgen[i] de type void **
20/04/2007, 15h17
Gruik

Si on veut se la jouer chacal, on peut se permettre de caster un int/long en void *, car il s'avere qu'un pointeur (de n'importe quel type) prend la meme place qu'un entier long sur pas mal de plateformes.
Mais faire ça c'est casser l'abstraction du sizeof

double prend plus de place qu'un int et donc ça ne rentre pas dans un void *
20/04/2007, 15h24
EnigmuS

merci,

encore un question alors pourquoi le type float qui est sur 4octets interdis aussi cela ?
20/04/2007, 15h46
Bob.Killer

Il faut utiliser les bonnes fonctions ;)

atol() Convert string to long (function)
atoi() Convert string to integer (function)
atof() Convert string to double (function)
20/04/2007, 15h51
EnigmuS

non non j'ai juste fais unmauvais copier coller je corrige le probleme n'est pas la
20/04/2007, 15h54
Thierry Chappuis

Citation:

Envoyé par Bob.Killer

Il faut utiliser les bonnes fonctions ;)

atol() Convert string to long (function)
atoi() Convert string to integer (function)
atof() Convert string to double (function)

Obsolète! On utilise aujourd'hui strtol(), strtol() et strtod() respectivement qui permettent une meilleure gestion des erreurs que ato*().

Thierry
20/04/2007, 16h28
EnigmuS

Une idée sur le fait que on puisse convertir void * en int/long (meme si c'est pas propre) à cause de la representation en memoire de 4octets et pas en float qui est aussi sur 4octets ?
20/04/2007, 16h38
Gruik

Ca y'est j'ai compris, on s'est emmelé les pinceaux.

Citation:

tabgen[i]= (long *)(atol(tabE[i]));

et pas ca :

tabgen[i]= (double *)(atof(tabE[i]));

Ici, le probleme n'est pas dans l'affectation du "long *" ou "double *" dans tabgen[i], le probleme est le castage du atol() et du atof() en pointeur.
atof() retourne tout le temps un double, donc tu pourras jamais caster le retour de atof en pointeur.
Si atof retournait un float alors ça serait peut être possible
Yaurait qu'a tester ceci
(double *)((float)atof(tabE[i]));
20/04/2007, 16h42
crocodilex

Citation:

Envoyé par Gruik

Yaurait qu'a tester ceci
(double *)((float)atof(tabE[i]));

Je ne vois pas trop l'interêt. Je trouve cette écriture complètement absurde...
20/04/2007, 16h44
EnigmuS

Oui mais mon compilo m'empeche de convertir un float ou un double vers leur pointeur respectif et donc encore moi un float vers un pointeur sur double c'est illégal

d'ailleurs c'est bizarre de pas pouvoir caster un float en float* alors qu'un long en long* on peut
20/04/2007, 16h48
Gruik

Citation:

Envoyé par crocodilex

Je ne vois pas trop l'interêt. Je trouve cette écriture complètement absurde...

Hé ho, j'ai pas dit qu'il fallait faire ça, c'était pour tester ce qu'autorisait le compilateur
20/04/2007, 16h49
Gruik

Citation:

Envoyé par EnigmuS

Oui mais mon compilo m'empeche de convertir un float ou un double vers leur pointeur respectif et donc encore moi un float vers un pointeur sur double c'est illégal

d'ailleurs c'est bizarre de pas pouvoir caster un float en float* alors qu'un long en long* on peut

Ok, j'ai dit des conneries alors (sur le coup du double trop grand pour rentrer dans un pointeur)
20/04/2007, 16h51
Médinoc

Il faut dire que dans tous les cas, ce genre de transtypage est un hack affreux.
Les seuls types de nombres qu'on devrait pouvoir convertir en pointeurs, sont intptr_t et consorts...
20/04/2007, 16h57
EnigmuS

bein si tu sais comment on déreference un pointeur (on obtient la valeur pointée) en assembleur ca m'intéresse car si je convertis comme ca pour les mettre dans le tableau génériquec'est pour générer la signature d'un appel à une DLL qui prend n'importe quoi comme type (pointeur ou pas) et qui est appelé via de l'assembleur alors quand j'ai des pointeurs sur double ca va mais quand j'ai des doubles ca aime moins

enfin je découvre et je galére y a surement d'autre solution et je vois bien que c'est moche :aie:

Bah le type du pointeur peut être modifié (on peut tres bien mettre un "double *" dans un "void *") ce qu'il faut pas faire c'est mettre un "scalaire" (entier, flottant, structure) dans un pointeur. Si ça doit arriver : donner l'adresse de ce scalaire -- à condition qu'il soit disponible tant qu'on maintient une pointeur sur lui -- la solution la plus sure est alors de "mallocopier" ce scallaire et de libérer cette copie quand on en a plus besoin
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void * ptr_gen; double mon_scalaire; double * tmp_ptr; mon_scalaire = 42.42; tmp_ptr = malloc(sizeof mon_scalaire); memcpy(tmp_ptr, &mon_scalaire, sizeof mon_scalaire); ptr_gen = tmp_ptr; /* -- plus loin : utilisation */ tmp_ptr = ptr_gen; /* à condition de savoir que c'est en fait un pointeur sur double */ mon_scalaire = *tmp_ptr; /* -- plus loin : liberation */ free(ptr_gen);
Une idee courante est de creer une structure contenant
1) le pointeur vers la zone où ya la copie de la valeur
2) un union avec tous les types dont on a besoin
3) un enum indiquant le type

Edit: avec cette structure il n'y a plus besoin de mallocopier un scalaire, une copie simple suffit

Citation:

Envoyé par EnigmuS

Une idée sur le fait que on puisse convertir void * en int/long (meme si c'est pas propre) à cause de la representation en memoire de 4octets et pas en float qui est aussi sur 4octets ?

Parce qu'une adresse (la valeur d'un pointeur) est un valeur entière. Cela peut donc faire un certain sens de convertir la valeur d'un pointeur en un entier inversément. Par contre, je ne vois aucune raison d'autoriser un cast d'un pointeur en double.

D'ailleurs, la portabilité du cast pointeur <-> entier n'est pas garantie. Selon la norme, le résultat de la conversion d'un entier en un type pointeur est définit par l'implantation. Ce résultat peut en effet ne pas être aligné correctement, et peut ne pas pointer sur un objet du type référencé. La conversion inverse est également définie par l'implantation, et le comportement est indéfini si la valeur du pointeur ne peut être représentée dans le type entier hôte.

A priori, il n'est pas garantit qu'un int ou long puisse recevoir la valeur d'un pointeur. Pour les raisons énoncées ici, la norme C99 a introduit les types intptr_t et uintptr_t, déclarés dans stdint.h, qui ont la propriété suivante:

"N'importe quel pointeur générique valide peut être converti dans ce type, puis re-converti en pointeur sur void, et le résultat de cette double conversion sera comparé égal avec la valeur du pointeur original".

Si vraiment tu tiens à convertir ton pointeur en double, et que ton compilateur est comforme à C99, rien ne t'empêche de procéder en deux temps comme ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> #include <stdint.h> int main(void) { int nombre = 10; int *pNombre = &nombre; uintptr_t pvaleur = (uintptr_t) (void *) pNombre; double pvaleur_dbl = pvaleur; return 0; }
Thierry

20/04/2007, 17h40
EnigmuS

Merci beaucoup à tous,

je regarderai tous ca lundi car la je suis plus au bureau lol

merci encore et bon week end
21/04/2007, 01h01
Emmanuel Delahaye

Citation:

Envoyé par EnigmuS

ah ok merci et pourquoi ca ca marche :

tabgen[i]= (long *)(atol(tabE[i]));

et pas ca :

tabgen[i]= (double *)(atof(tabE[i]));

avec tabgen[i] de type void **

Tu as vu une adresse quelque part ?

Arrête de faire n'importe quoi et réfléchi...
24/04/2007, 10h46
EnigmuS

Le problème n'est pas qu'il y ai une adresse quelque part mais de caster le type void en int/long/double en filoutant (cast de void * et long * etc...) je sais que c'est trés moche Emmanuel pas besoin d'enfoncer le clous lool

alors si tu sais contourner ce type d'écriture en C je t'en prie :oops: mais j'ai vraiment besoin d'avoir le type réel dans ce tableau car sinon dans mon asm il considére ca comme un pointeur et me fait un General Protection fault alors qu'avec tabgen[i]= (long *)(atol(tabE[i])); il m'affiche le bon résultat.

J'aimerais contourner ca et apparemment c'est possible en C99 mais y aurait-il moyen d'avoir plus d'explication sur intptr_t, j'ai cherché d'autre example mais j'avoue ne pas bien comprendre. intptr_t est un entier signé pouvant stocker un pointeur mais j'arrive pas a voir ou ca empeche de faire ce qui a plus haut arf

Merci d'avance.
24/04/2007, 11h13
Emmanuel Delahaye
Citation:

Envoyé par EnigmuS

alors si tu sais contourner ce type d'écriture en C je t'en prie :oops: mais j'ai vraiment besoin d'avoir le type réel dans ce tableau

Un type void* est un pointeur sur n'importe quel objet. Ce n'est pas un objet qui peut contenir n'importe quoi.

Par exemple :
Code:

1 2 3 4 5 6 7 8 9 void *p = malloc (sizeof (double)); double *pd = p; *pd = 12.34; ... free (p), p = NULL, pd = NULL;
est correct mais

Code:

void *p = (void*) 12.34;

est non seulement faux (comportement indéfini), mais totalement illogique.