Discussion :

[Invité]

Salut j'utilise CEGUI

et je dois utiliser une fonction qui renvoit void* (j'avais jamais vu ça avant)

voila la fonction:

void* CEGUI::Window::getUserData ( void ) const [inline]

Return the user data set for this Window.

Each Window can have some client assigned data attached to it, this data is not used by the GUI system in any way. Interpretation of the data is entirely application specific.

Returns:
pointer to the user data that is currently set for this window.

[petit.quent]

VOID signifie "vide" ce qui signifie que la fonction ne renvoie rien.

[Invité]

non je parle de Void* pas de Void

[BlueMonkey]

Bonjour,

void * est un pointeur sur un type non définit.
Ce type de pointeur est utilisé, lorsque le type de pointeur qui lui affecté change suivant les situations.
On pourra réutiliser les données se trouvant à l'adresse pointée par ce type de pointeur, en faisant un casting.
(suivant le cas à l'aide de dynamic_cast (reinterpret_cast) ou bien int * pInt = (int *)getUserData ()


Le tout étant de se rappeler le type de donnée qu'on a passé à cet élément graphique setUserDate( void *)

Pour aller plus loin voir >>ici<<

[koala01]

Salut,

void* est, effectivement un pointeur sur le type void...

Bien que le type void signifie, effectivement, vide, et qu'une fonction ayant un prototype proche de void foo() ne renvoie effectivement rien, une fonction renvoyant un pointeur sur void (ayant donc un prototype proche de void* foo() ) sera considérée, en C, comme une fonction renvoyant un pointeur sur un type non connu

C'est une technique régulièrement utilisée en C, que ce soit pour la valeur de retour de fonction ou pour les arguments à fournir à une fonction, pour remplacer certains concepts inexistants en C tels que:

• la généricité ( dont on dispose en C++ sous la forme de template-
• le concept d'héritage (dont on dispose en C++ sous la forme de la programmation OO)
• la surcharge de fonction (qui est autorisée et amplement utilisée en C++)

Il va sans dire que si cette technique est indispensable en C, il est fortement recommander de la fuir comme la peste en C++, tant il existe de solutions pour l'éviter (en plus, il y a toujours le problème de savoir quel est le type réellement utilisé ou renvoyé par une fonction prenant un pointeur sur void comme argument ou renvoyant un tel pointeur )

Sauf erreur de ma part, le static_cast et le dynamic_cast ne fonctionneront pas, simplement parce que ce sont des transtypages (et oui, voilà la traduction officielle de "cast" ) utilisés dans des contextes d'héritage, et que rien ne dérive de void (qui n'est d'ailleurs pas une structure ni une classe, et qui ne peut donc pas être utilisé comme "classe de base" )

Le transtypage qu'il faut utiliser est le reinterpret_cast, de préférence au transtypage "C style" (proche de (unType*) variable) essentiellement pour des raisons de lisibilité du code et pour permettre une recherche plus facile dans un projet

Ce transtypage (reinterpret_cast) indique au compilateur "cette variable que tu connait comme étant ( de type pointeur sur void, vu que c'est ce qui nous intéresse ) est en réalité (un pointeur sur le type indiqué), et a donc exactement le meme effet qu'un transtypage "C style", la lisibilité en plus

[JolyLoic]

Si dynamic_cast ne fonctionnera pas, car effectivement il ne dispose pas des informations nécessaires pour effectuer ses vérifications, static_cast marchera lui, à condition que le type que l'on demande soit le même type que le type que l'on a mis initialement (ça peut aussi marcher si on demande un type qui est un type de base, mais rien n'est assuré, surtout en cas d'héritage multiple).

[Luc Hermitte]

Les casts vers et depuis void* doivent être des static_cast ... en C++98/03 (http://www.open-std.org/jtc1/sc22/wg...ects.html#1120)
Un exemple : http://www2.research.att.com/~bs/bs_faq2.html#void-ptr
Le pourquoi ? Je soupçonne que c'est du à la non garantie que sizeof(void*) == sizeof(T*), ou à un mauvais phrasé du standard de 98, je ne sais pas.