void* et float/double

Bonsoir,

Un petit probleme de passage de variable se pose dans mon programme:

J'enumere les differents specifiers a l'aide de l'utilisation de pointeurs sur fonctions et avec les va_arg je suis oblige d'envoyer un void* pour l'envoi des donnees a mes fonctions. (mmm c'est pas clair :? )

Exemple:
j'ai sa dans mon main:

Code:

---

1 2 3 4 5 6

while (gl_specifier[count].specifier != 0) { if (gl_specifier[count].specifier == *str) gl_specifier[count].ptr_func(va_arg(va, void*), &gl_option); count++; }

---

et en resume j'envoi l'argument de type void* a:

Code:

---

1 2 3 4 5

void float_number(float nb, t_option *gl_option) { printf("%f", nb); }

---

donc void* -> float.

Mais le printf m'affiche 0.0000... Le float est donc mal transfere et je ne vois pas comment faire autrement...

Si quelqun a une idee :)

Merci!

Pourquoi tu n'utilises pas tout simplement le type float au lieux de void* dans ta macro va_arg :)

Code:

---

va_arg(va, float)

---

Après pourquoi ça ne fonctionne pas avec le type void je ne suis pas sûr ...
Et pour ne pas dire de bêtises je ne vais pas me prononcer :aie:

En faite, ca ne pointe pas que sur cette fonction qui recoit un float, sa pointe sur des fonctions recevant des int, des char donc non je ne peux pas :)

je ne suis pas sûr d'avoir compris ton problème.

Ce que je crois avoir compris :
gl_specifier est un tableau de structures dont un des champs ptr_func est un pointeur sur une fonction dont les arguments sont du type void * et t_option * et qui retourne void.

float_number est une de ces fonctions. Son prototype doit donc être

Code:

---

void float_number( void *, t_option *)

---

Dans le code, il faut restituer le type exact du premier argument (et ne pas se tromper)

Code:

---

1 2 3 4

void float_number(void * pnb, t_option *gl_option) { printf("%f", *(float*)pnb); }

---

Merci pour ta reponse diogene,
Effectivement c'est ca,
une autre de mes fonctions qui recoit un void* (et qui fonctionne):

Code:

---

1 2 3 4 5

void decimal(void* va, t_option *gl_option) { my_put_nbr((int)va); }

---

et dans cette fonction le nombre va est bien restitue.

Apres l'ajout de tes modifications ca compile mais j'ai le warning suivant:

Code:

---

specifier_1.c:58: warning: incompatible implicit declaration of built-in function 'printf'

---

et donc comme j'envoi un mauvais type a printf un beau segfault apparait lors de l'execution du soft :/

as-tu inclus <stdio.h> ?
Si oui, montre le code incriminé.

J'ai laissé tomber cette piste en fin de compte, apres quelques recherches sur le net j'ai vu qu'il y avait des problemes entre les float/double et void* :/ .

Merci quand meme!
Bonne journee

J'ai du mal à voir quel problème exactement.

Bien sûr, personne ne serait assez idiot pour tenter de faire tenir un double "dans" un void* sur un système 32 bits, mais un void* peut sans problème pointer sur un double...

J'ai teste toutes les facons possible pour faire passer mon float, les facons idiote et normale et ca ne fonctionne pas.

Je suis d'accord que ca:

Code:

---

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

void float_transfer(void* nb) { printf("%f", *(float*)nb); }   int main(int ac, char **av) { float test; test = 12.235;   float_transfer(&test); return (0); }

---

Ca fonctionne mais dans mon cas ou j'utilise les va_arg ca ne fonctionne pas

Une remarque qui peut être est en rapport avec tes difficultés :

Si je considère ce genre de code :

Code:

---

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

void float_transfer(void* nb) { printf("%f", *(double*)nb); } void f1(int n, ...) { double v ; va_list ap; va_start(ap,n); v = va_arg(ap,double); va_end(ap); float_transfer(&v); }   int main(void) { float test; test = 12.235; f1(0,test); return 0; }

---

v dans f1() prendra la valeur correcte et l'affichage sera correct.
Par contre si dans f1() on remplace double par float, le résultat est faux dès la valeur v obtenue dans f1() :
En l'absence d'un prototype complet de f1, le deuxième argument dans l'appel de f1 (c.a.d. test) sera promu en double, même si test est un float.

Conclusion , la fonction f1 ne peut pas recevoir un float en argument.

Voila mon probleme est celui-ci justement, je ne connais pas le type de la valeur envoye.
Mon probleme vient de ca:

Code:

---

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

#include <stdarg.h>   void float_transfer(void* nb) { printf("%f", *(double*)nb); }   void f1(int n, ...) { //double v; va_list ap; va_start(ap,n); float_transfer(va_arg(ap, void*)); va_end(ap); }   int main(void) { float test; test = 12.235; f1(0,test); return 0; }

---

vous pouvez constater que ca fonctionne pas ce cas la :/

Et comme ça :

Code:

---

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

void float_transfer(void* nb) { printf("%f", *(float*)nb); }   void f1(int n, ...) { va_list ap; va_start(ap,n); float_transfer(va_arg(ap,void*)); va_end(ap); }   int main(void) { float test; test = 12.235; f1(0,&test); return (0); }

---

Effectivement dans ce cas la ca fonctionne!

Mais le truc c'est que je recode printf, et quand on fais un printf on a pas besoin d'envoyer l'adresse de notre float.
Mais oui ca marche avec mon code si j'envoi l'adresse du float (my_printf("%f", &float_var)). Mais ca marche que comme ca :( sinon sans envoyer l'adresse = segfault.

Je ne sais pas trop comment tu recodes printf, mais en fonction des paramètres fournis dans la chaîne de caractères tu peux savoir le type de données qui sont demandées et donc envoyer le bon type à ta fonction sans utiliser des (void*).
Un switch suffit :)

Je prefere les pointeurs sur fonctions, ca m'evite de faire des codes a rallonge, et pour recoder la gestion des flags de formatage (de printf) c'est plus flex.
Merci quand meme pour le conseil ;)

bon j'ai fait pointeur sur fonction pour la majorite des types a part pour les float et double ou j'ai fais du if, ca fonctionne.

Bonne fin de soiree