Bonjour,
 
j'aimerai savoir si quand on fait une fonction
 

 
ca veut dire qu'on peut faire des traitement sur les adresses, mais par exemple est ce qu'on peut faire des traitements sur les valeurs ??? Par exemple si on passe à la fonction :
 

 
est-ce possible ? est ce possible que la fonction programmée fasse des opérations sur la valeur *toto, étant donnée que c'est un type void   . Je sens bien que non ....mais heu oui j'aime me faire flageller ?      
 
 
 

Non, on ne peut pas faire d'opération sur le contenu d'une adresse pointée par un void*, c'est un pointeur générique. Si tu veux pouvoir en faire quelque chose (du contenu de l'adresse blabla), il faut au minimum un second paramètre, pour donner la taille unitaire d'un élément. Et si ton void* est un tableau d'éléments, il te faut aussi donner à la fonction le nombre d'éléments...

t'as essayé de compiler ça ?

Euh, aucun problème :

#include <stdio.h>
 
int machin(void *truc)
{
   return 0;
}
 
int main(void)
{
   int i = 42;
   
   return machin(&i);
}

Juste, en l'état, ça ne sert à rien.

(donc la réponse à sa question aurait été "oui c'est possible techniquement", avant développements).

(j'comprends pas bien, je réponds à sa question, non ? )

(oui bien sûr, mais je pars du principe que le gars comprends mieux en manipulant lui même)

C'est tout à fait possible, mais tu ne sera pas capable de déréférencer toto. Pour accéder à ce qui est pointé par toto, il faudra le caster avant de le déréfencer, ce suppose que tu connais pas ailleurs le type pointé par toto.

Par contre les cas sont rares où l'ont peut écrire une fonction admettant un void* comme argument, et "connaissant" le type du paramètre (on peut par exemple imaginer une structure avec un void* dedans, et un champ de la structure permettant de déduire le type du void* selon les cas).

 
Pas tant que ça, regarde du coté des pthread ou d'autres callbakc géénriques.

les void* sont souvent utiliser comme pointeur vers des fonctions. Sinon c'est vrai que je n'en vois pas l'interet non plus.  
 
On peut le comparer à Object dans les languages orientés objets tel que Java ou C#...  ça n'a que peux d'interet...

Surement pas !

Un pointeur de fonction, c'est ça : <type>(*fonctionquelconque)(paramètres, ...)

exemple : int *pointeurDeFonction(int machin, double bidule, const char * const * truc);

Y a plein d'intérêt au void*, on discutait juste ici de la possibilité d'exploiter les données à l'adresse pointée par un void*, avec juste ce pointeur à disposition.
Le type void* est un outil comme un autre, il a donc plein d'intérêts.

Euh... non.

T'as bien mis les parenthèses dans ta description... alors pourquoi tu les oublies ici ?
Là, on a une fonction nommé "pointeurDeFonction" qui renvoie un pointeur sur un int    
 

Une fois, à mes débuts, j'ai utilisé un pointeur de ce type. J'avais besoin d'afficher le login et le nom du groupe de l'utilisateur du programme. Et comme c'était vraiment ponctuel, j'ai utilisé la même variable qui recevait successivement

• un pointeur sur une structure de type "struct passwd"
• un pointeur sur une structure de type "struct group"

Les deux structures étant différentes, je n'ai pas eu d'autre solution que de déclarer ma variable de type "void*". Ensuite, lorsque je voulais me servir de ce pointeur en tant que "struct passwd*", je faisais un cast. Idem pour l'autre.
Bon, c'était horrible j'admets.
 

 
Ben il y a qsort() qui peut trier un tableau de n'importe quoi (il y a donc forcément traitement sur les valeurs). Toi tu passes en premier paramètre à cette fonction l'adresse de ton tableau. Comme cette fonction est universelle (tu peux lui passer l'adresse d'un tableau de n'importe quel type), elle stockera cette adresse dans un pointeur de type "void *".
Bien évidemment, comme le dit Elmoricq, il faut passer à la fonction d'autres infos pour qu'elle puisse manipuler correctement ce pointeur...

Parce que je les ai oubliées dans l'exemple, rien de plus.  

Arf brain failure...

Non. Merci d'éviter de sortir des aneries pareilles. void * est un type "pointeur générique" sur objet. Certainement pas sur fonction (comportement indéfini).

Quand à l'utilité, elle concerne évidemment la programmation générique. Par exemple :

http://mapage.noos.fr/emdel/complog.htm

ou

http://mapage.noos.fr/emdel/clib.htm
Modules GLL, GFIFO etc.

Le but n'est pas de faire des traitements sur des adresses, mais de passer de façon 'anonyme' (ou générique) l'adresse d'un objet à une fonction, dans le but de faire des traitements indépendamment du type.
 
Bien sûr, en fonction du traitement à faire une indication sur la taille de l'objet pointé peut être utile (qsort(), par exemple).
 
Mais dans le cas d'un callback, c'est le programmeur qui doit passer l'adresse d'un type bien défini au moment de l'appel, et c'est lui qui sait donc quel est le type attendu. (le plus simple étant de gérer un pointeur local typé selon les désirs de l'utilisateur dans le callback).

Je ne connais pas trop les callback (ou alors je les connais sous un autre nom). Tu pourrais me donner un exemple STP ?
En fait, j'arrive pas trop à m'imaginer pourquoi le programmeur doit programmer une fonction qui recevra un "void *" puis dans la fonction il devra faire le branchement sur le bon type alors que manifestement il connaît le type du paramètre qu'il lui envoie => autant mettre directement le bon type (ou alors j'ai rien pigé)...

As-tu lu mon article sur les composants logiciels cité au-dessus ?
 
C'est comme ça qu'on code les 'évènements' (idem windows, gtk+ etc.)
 
As-tu déjà utilisé qsort() ?
 
Le principe de la programmation générique est que le maximum de code est unique et placé en bibliothèque, mais que ce qui est lié à l'application. Ici, la fonction de comparaison est confiée au programmeur. Les paramètres de la fonction de comparaison (adresse des éléments) sont évidemment de type void * (en l'occurence, void const *), car la fonction appelante, ne connait pas le type, par définition.

Non, et je ne vois pas trop où il peut être sur ton site...
 

Tout à fait. Mais cette fonction ne travaille absolument pas comme tu as décrits le callback ("une fonction qui sait quel est le type attendu et qui choisit le type qu'il faut au moment de l'appel" si je lis bien)
qsort() reçoit un tableau générique, le nombre d'éléments, la taille d'un élément. Et grace à cette taille, elle peut déplacer les éléments en interne pour les trier. Mais en interne, elle ne bosse que sur des caractères (probablement à coup de memcpy). Elle ne "choisit" donc pas le type. elle utilise le type le plus primitif qui puisse exister...
 

Oui, je connais ce principe et je me suis moi-même amusé à programmer un "tri par arbre" universel sur le même principe que qsort(). Mais là aussi il est impératif que ma fonction connaisse la taille d'un élément
 

En fait, quand je lis cette phrase, j'en déduis qu'une fonction peut utiliser un type générique sans connaître la taille de l'élément qu'on lui passe et j'arrive pas à m'imaginer comment elle peut faire...

http://mapage.noos.fr/emdel/complog.htm

Ca, c'est en interne, mais regarde bien le prototype de la fonction de comparaison, qui est une fonction de callback.

Tout à fait. Mais encore une fois, je parle de la fonction de comparaison (le callback), et non de la fonction de tri.

Elle se contente de passer l'adresse. Il ne faut pas confondre 2 usages des void * illustrés par qsort.  
 
1 - la programmation générique. Un objet est défini par un couple adresse (anonyme) / taille (en char). : void* / size_t. S'y ajoute le nombre d'éléments, puis qu'il s'agit d'un tableau. Exemple courants : qsort(), fwrite() etc.  
 
2 - le callback qui reçoit l'adresse de la ou des données à traiter (ici, 2 données en lecture seule à fin de comparaison). Cette adresse est évidemment anonyme, puisque le callback est lui-même générique. C'est dans la fonction de callback que l'on 'spécialise' en mettant le bon type grâce à des pointeurs intermédiaires (il existe des méthodes plus gores, mais je n'en parle pas) :  

EVIDEMMENT !!!
Le callback c'est le pointeur sur la fonction de comparaison qu'on passe à qsort(). Et le prototype de ce pointeur de fonction ne peut être que "int (*ptFct)(void *, void *)" puisque le programmeur de qsort() ne connait pas à l'avance les types qu'elle devra traiter !!!    
 
Merci de l'exemple    
 
Ce qui m'empêchait de bien piger, c'est que si c'est moi qui avait écrit "cb_compare()", je l'aurais écrit directement

En me disant << le prototype de ptFct() dans qsort() reçoit deux pointeurs universels, je peux donc lui passer une fonction traitant deux pointeurs sur "T" sans crainte >>. Mais je présume que c'est peut-être pas forcément la meilleure façon d'écrire "cb_compare()" n'est-ce pas ???

Tu aurais eu un 'type incompatible' au moment de l'appel de qsort, car il attend l'adresse d'une fonction dnt le prototype est clairement défini :  

C'est donc :  

si on met autre chose, le comportement est indéfini.

C'est là qu'on voit le minuscule détail qui fait la différence. J'ai toujours cru qu'un pointeur de type "void *" étant "universel" c'est à dire qu'on pouvait y mettre un pointeur sur n'importe quoi, j'en ai conclu qu'un prototype attendant un "void*" pouvait recevoir un "<truc> *"...
 
PS: J'aime pas quand on me dit que le comportement est indéfini parce que, dans 99,9% des cas, le comportement est tel qu'on s'y attend. Ex:

• pas de return dans le main => comportement indéfini => j'ai toujours vu une sortie à "0"
• définir une fonction avec un paramètre "(<type> *)" alors qu'elle est prototypée "(void *)" => comportement indéfini => dans 99% des cas, il y aura cast implicite

 
On le peut, sauf erreur de ma part:
 

Pas testé la compile...

exact (enfin objet, OK ? pas fonction).

Oui. Mais ici il s'agit de la définition d'un pointeur de fonction. Si le prototype de la fonction n'est pas strictement identique, tous les compilateurs que je connais signalent une erreur ou un warning.

QoI : (Quality of Implementation) en C90, repris en C99. (le return 0 de main() est devenu facultatif, c'est pas la peine de le répéter...)

Ben c'est normal. Le prototype et la fonction doivent être identiques. Sinon, c'est le b*rd*l

bonjour,
 
merci pour toutes les explications .... J'aurais encore une question si vous le voulez bien :
 
Quand on fait une fonction avec une liste d'arguments, et que la liste des arguments comporte pleins de types différents, comment fait-on ? On créer une structure ou y'a mieux à faire (void ??) ??
 
 
par exemple une fonction avec une liste d'arguments int, double et char :
 

 
ou bien ??

C'est une solution. Le regroupement par structure doit avoir une logique liée à l'application elle-même. C'est une question de conception.

On peut aussi laisser les arguments un par un, surtout si il n'y a pas de pointeurs, mais ça multiplie les copies... Et si il y a 30 paramètres, ça va être facile à gérer. Bref, c'est un peu au cas par cas. Que veux-tu faire exactement ?

 
salut,
 
en fait c'était en référence à la question su les pointeurs de fonctions. Si par exemple on veut un poiteur sur une fonction qui fait une opération, mais que cette opération peut prendre en arguments des doubles, ou des float, etc. Dans ce cas comment fait-on ?

Je serais tenté de dire qu'il faudrait architecturer ton appli différemment de manière à ce que ta fonction prennent toujours des arguments du même type (l'utilisation d'un enum + struct entre dans ce cas de figure). Si ce n'est pas possible, je vois deux solutions :
 

• Tu passes à ta fonction un void *, justement, ainsi qu'un paramètre supplémentaire qui permet de connaître le type référencé. Evidemment tu ne peux pas passer tes paramètre par valeur de cette façon.

• Tu utilises les va_arg comme le fait printf

• Tu utilises une structure avec un sélecteur et une union. C'est plus clair que les variadics ou qu'un void*. C'est déterministe.

Oui, c'était ma parenthèse

Ah, oui, en effet. Elle méritait un  

que pensez vous de l'exemple suivant, qui utilise un void ? C'est ce à quoi je pensais ...

C'est un bout de code d'exmple d'une librairie mathématique (gsl). Dans l'exemple, on initialise une fonction avec une liste de paramètres  pointé par un void *. Y'a des cast un peu partouts, et je ne comprend pas bien l'interêt....Pourriez vous m'éclairer ?

le lien http://www.gnu.org/software/gsl/ma [...] o-minimize

l'exemple :

Je présume que tu parles de ces cast là...

C'est obligatoire. La variable "params" est un pointeur sur un truc indéfini (un truc qui peut être char, short, long, etc... d'où le terme "pointeur universel" ).
 
Si tu commences à vouloir manipuler "*params" (ce qu'il y a à l'adresse stockée dans "params" ); le compilo ne saura pas si, à partir de cette adresse de départ, il faut récupérer un octet (char), 2 octets (int), 4 octets (long/float) ou 8 octets (double) puisque "*param" est indéfini
 
Donc le programmeur, qui connaît ce qu'il reçoit, stocke ce qu'il reçoit dans la variable "dp" qui est un type connu. Ensuite, il pourra utiliser "*dp" autant qu'il voudra.
Le cast c'est juste pour éviter les warning. Un pointeur étant toujours un pointeur, on peut très bien écrire "dp=params" mais le compilo préviendra en disant "attention, êtes-vous sûr de ce que vous faites" donc cast

  C'est pas du tout obligatoire en C...

est du C parfaitement valide et standard...

Exact - C'est écrit à la page 199 du K&R (1er paragraphe). En fait, c'est obligatoire pour tout autre pointeur que "void *" d'où ma confusion.
Comme d'hab, tu maîtrises l'extrème soucis du minuscule détail qui font et feront toujours la différence. Ptet un brin agaçant tout de même