passer un parametre dans un void *

Bonjour,

Je dois écrire une fonction qui doit être de la forme ma_fonction(void * param) car son appel sera géré par une autre fonction qui enregistre les paramètre sous la forme void * puis appelle ensuite la fonction avec ce paramètre.

Je voudrai que ma_fonction reçoive un int comme paramètre et puisse y accéder.
Comment faire?

Merci

Pour préciser un peu (c'est pas facile a expliquer), je voudrai que ca ressemble a ca, qui doit etre faux :

Code:

---

1 2 3

void ma_fonction (void * param) { int mon_int = (int)param; }

---

Si ma fonction d'appel ressemble a ca :

Code:

---

void fonction_appelante(void *Fonction,void *Param);

---

Et lorsque je demanderai a la fonction d'apel d'enregistrer le parametre a envoyer a ma_fonction je lui passerai :

Code:

---

1 2	int i = 0; fonction_appelante(ma_fonction,i);

---

2 / si l'appelant founit un int

Code:

---

1 2 3 4 5

void ma_fonction(void * param) { int value = (int) param; }

---

T'auras surement un warning au niveau du compilo, mais cela fonctionnera..

2 /si l'appelant founit un int *

Code:

---

1 2 3 4 5

void ma_fonction(void * param) { int *value = (int *) param; }

---

l'appelant fournit un void *
C'est moi qui veux fournir a l'appelant un int qu'il me redonnera sous forme de void * :
void fonction_appelante(void *Fonction,void *Param);

Ca serait mieux si tu pouvais lui passer un int * car dans ce cas le cast est plus propre et plus logique !

Citation:

---

Envoyé par pasdeface

l'appelant fournit un void *
C'est moi qui veux fournir a l'appelant un int qu'il me redonnera sous forme de void * :
void fonction_appelante(void *Fonction,void *Param);

---

je ne sais pas, mais si la fonction_appelante attend toujours un int, alors il auras pas de problème; il suffit d'affecter le pointeur void * avec ce lui de l'entier.

Code:

---

1 2 3 4 5 6 7 8 9

void ma_fonction(void * param) { int *retValue; retValue = malloc(sizeof(int)); .... *retValue = value; param = retValue; }

---

Pour la fonction appelante :

Code:

---

1 2 3 4 5 6 7

void fonction_appelante(void *Function, void *param) { int retValue; Function(param); retValue = (int *) param; .... }

---

ma fonction appelante est une fonction générique qui peut apeller d'autres fonctions avec différents type de paramètres. De plus ce n'est pas moi qui l'ai écrite et c'est une fonction existante.
Donc quelle est la syntaxe pour passer un int? ou faut il obligatoirement passer un int * ?

Apparemment,fonction_appelanteprend pour premier argument une fonction. Le type de cet argument est incorrect. On devrait avoir logiquement quelque chose suivant la trame ci-dessous :

Code:

---

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

void ma_fonction (void * param) { int mon_int = *(int*)param; //..... }   void fonction_appelante(void (*Fonction)(void*),void *Param) { //.... Fonction(Param); //.... }   int main(void) { int i =123; fonction_appelante(ma_fonction,&i); return 0; }

---

Citation:

---

Envoyé par pasdeface

ma fonction appelante est une fonction générique qui peut apeller d'autres fonctions avec différents type de paramètres. De plus ce n'est pas moi qui l'ai écrite et c'est une fonction existante.
Donc quelle est la syntaxe pour passer un int? ou faut il obligatoirement passer un int * ?

---

Donc, il te faut juste un cast sur l'entier, mais il faut que la fonction appelé soit adapter pour qu'elle gére les entier à partie d'un void.

Code:

---

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

int main(void) { int value; fonction_appelante(ma_fonction, (void *)&value); return 0; }   void ma_fonction(void *param) { int value = *((int *)param); //si tu utilise un argument input ..... param = value // si tu utilise un argument output }

---

Citation:

---

Envoyé par cmoibal

Code:

---

1 2 3 4 5 6 7 8 9

void ma_fonction(void * param) { int *retValue; retValue = malloc(sizeof(int)); .... *retValue = value; param = retValue; }

---

---

Tu te rends compte de ce que tu écris ??????

Code:

---

param = retValue;

---

ne sert a rien car param n'est pas modifié en retour de fonction

Et puis pourquoi allouer de la mémoire car elle ne sera pas libérée...

pasdeface, tu passes un int ou un int * à la fonction et tu castes dans la fonction..

C'est toi qui ecris les deux fonctions ? ou sinon laquelle ? Soit plus clair

Suis la solution de diogene

Citation:

---

Envoyé par diogene

Apparemment,fonction_appelanteprend pour premier argument une fonction. Le type de cet argument est incorrect.

---

En fait elle enregistre la fonction dans une structure pour pouvoir la rapeller ensuite.
Donc les paramètres de fonction_apellante sont déclarés comme ça :
(void *Fonction,void *Param)
Et Fonction est la fonction a rappeler plus tard. Elle est enregistrée dans une structure déclarée comme ca :
int (*pFcontion)(void *);
(elle renvoie en fait un int mais peut importe le problème n'est pas là).
C'est toujours incorrect? En tout cas ca marche bien pour les autres fonctions déjà crées et qui l'utilisent.

Citation:

---

Envoyé par vicenzo

C'est toi qui ecris les deux fonctions ? ou sinon laquelle ? Soit plus clair

---

Je l'ai dit pourtant :
" ma fonction appelante est une fonction générique qui peut appeler d'autres fonctions avec différents type de paramètres. De plus ce n'est pas moi qui l'ai écrite et c'est une fonction existante."
J'ai écrit seulement ma_fonction.

Je vais donc suivre la solution de diogene qui a l'air de bien correspondre à ce dont j'ai besoin, et je vous dirai si ca marche.

Merci beaucoup !

J'ai une question par rapport a la solution de diogene :
Si je suis dans une fonction F1 lorsque j'appelle fonction_apellante, et que je lui donne l'adresse d'un int, le problème c'est que lorsque je vais quitter F1 ce int va etre détruit, et lorsque plus tard fonction_appelante va appeler ma_fonction avec l'adresse du int, il n'existera plus, non?

Edit :
Bon je pense que oui, donc la solution que je vois serai de faire un malloc pour me réserver la place mémoire pour mon int, et lorsque ma fonction est appelée je fait un free sur mon paramètre.

Ça vous semble correct?

merci

Citation:

---

Envoyé par pasdeface

Code:

---

1 2 3

void ma_fonction (void * param) { int mon_int = (int)param; }

---

Code:

---

void fonction_appelante(void *Fonction,void *Param);

---

Code:

---

1 2	int i = 0; fonction_appelante(ma_fonction,i);

---

---

Un paramètre générique void * est fait pour passer une adresse de variable et rien d'autre. Il faut que ce soit absolument clair. un int n'est pas compatible avec une adresse.

Une solution est :

Code:

---

1 2 3 4

void ma_fonction (void * param) { int *p_int = param; int mon_int = *p_int; }

---

Code:

---

void fonction_appelante(void *Fonction,void *Param);

---

Code:

---

1 2	int i = 0; fonction_appelante(ma_fonction,&i);

---

Citation:

---

Envoyé par cmoibal

Code:

---

1 2 3 4 5 6

int main(void) { int value; fonction_appelante(ma_fonction, (void *)&value); return 0; }

---

---

Horriblement faux. La conversion int -> void* n'est pas garantie en C. Le comportement est indéterminé (pour simplifier).

Citation:

---

Envoyé par pasdeface

Ça vous semble correct?

---

Si le risque est avéré (threads, par exemple), oui.

Citation:

---

Envoyé par Emmanuel Delahaye

Un paramètre générique void * est fait pour passer une adresse de variable et rien d'autre.

---

oui j'avais bien dis "je voudrai que ça ressemble a ça, qui doit être faux".
Je voulais connaitre la manière correcte de procéder, et je penses donc avoir ma réponse, j'essaye ca.
Merci

C'est pour cela que diogene et moi lui ont indiqué de passer un int * à sa fonction....

Emmanuel, tu peux écrire plus gros ? :lol: