Discussion :

[guitou99999999]

Bonjour,

J'ai une fonction qui me retourne un void * dans un de mes programmes. Mon probl�me est que je voudrais r�cup�rer la valeur point� par ce void*. La seule mani�re que j'ai trouv� et de caster ce pointeur sur le type de donn�es sur lequel il pointe. Par exemple je sais que mon void * pointe sur un unsigned long. Donc je caste mon void* en unsigned long* et je retrouve ma valeur. Mais dans le cas ou je ne sais pas que c'est un unsigned long comment je peut faire ??

Merci pour vos r�ponses !!

[cob59]

C'est pour cette raison qu'on �vite de traiter des void*.
En C++ on peut quasiment toujours passer par un �quivalent template :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
template <typename T>
T* func()
{
  return new T;
}

[Neckara]

C'est pour cette raison qu'on �vite de traiter des void*.
En C++ on peut quasiment toujours passer par un �quivalent template :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
template <typename T>
T* func()
{
  return new T;
}

Ceci ne marchera pas, tu ne peux pas avoir deux fonctions de m�me nom avec les m�me arguments (ou de m�me avec les m�thodes d'une m�me classe) qui ne diff�rent que par leur type de retour.

@guitou99999999 :
Une des solutions serait de stocker dans une structure le pointeur void et un identifiant qui indiquera le type stock� et retourner ta structure au lieu d'un pointeur void mais ce n'est pas tr�s pratique

Une autre solution serait, au lieu d'utiliser un void * utiliser un std::string au sein d'une classe avec des m�thodes de conversions :
- implicites : int valeur = monInstance;.
- explicites : int valeur = (int)monInstance;.
ou int valeur = monInstance.toInteger(); ou int monEntier ; monInstance.convert(monEntier);.

On peut aussi ajouter des tests : monInstance.isInteger(); // si la conversion vers un entier est possible.
Ainsi tu ne pourras pas vraiment savoir le type d'origine mais tu pourras obtenir le "type que tu souhaites".

Apr�s, difficile de te r�pondre plus pr�cis�ment sans plus de d�tails.

[cob59]

@Neckara
Tu confonds surcharge et sp�cialisation.
Ce code fonctionne, et permet de conserver statiquement l'information du type de la donn�e allou�e, au lieu de la d�truire par un cast en void* :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
template <typename T>
T* func()
{
  return new T;
}
 
int* i = func<int>();
double* d = func<double>();

--edit--
Si on t'impose des fonctions qui traitent du void*, il y a toujours la possibilit� d'un wrapper. Exemple classique avec des fonctions malloc/free :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
// Ce qu'on te fournit
void* custom_malloc(int type);
void custom_free(void* ptr, int type);
int custom_integerType = 1;
int custom_floatType = 2;
int custom_doubleType = 3;
 
// Ton wrapper
template <T>
struct Wrapper {
  Wrapper() { ptr = (T*)custom_malloc(CustomType); }
  ~Wrapper() { custom_free(ptr, CustomType); }
  const T& get() const { return *ptr; }
  void set(T& value) { *ptr = value; }
private:
  T* ptr;
  static int CustomType;
};
 
int Wrapper<int>::CustomType = custom_integerType;
int Wrapper<float>::CustomType = custom_floatType;
int Wrapper<double>::CustomType = custom_doubleType;
(...)
 
Wrapper<int> a;
a.set(42);
 
cout << a.get() << endl;

Pas test�, mais l'id�e est l�.
La classe Wrapper est simplissime d'utilisation, et tu �vites les mauvaises (d�s)alloc.

[Neckara]

Mea culpa,

Par contre, tu ne r�ponds pas au probl�me de l'utilisateur car tu pars du principe qu'il sait, lorsqu'il appelle sa fonction quel type sera retourn�e/doit �tre retourn�. Ce qui n'est pas le cas.

EDIT :
L'id�e de Wrapper est pas mal, mais en fonction de l'algorithme du posteur, il est possible que cette m�thode ne marche pas.

Si on veut retourner un "Wrapper" au sein d'une fonction, on ne pourra pas vraiment (on se ram�nerait au probl�me originel).

Dans ce cas, il faudrait cr�er une classe Mere dont Wrapper h�riterait.
Puis caster Wrapper en fonction des informations contenus dans Mere.

Or, on peut aussi penser � fournir dans Mere des m�thodes virtuelles isMachin(), etc...
Ce qui nous ram�nerait � ma seconde solutions (en d�rivant pour "optimiser" certaines m�thodes en fonctions de certains types particuliers).

EDIT : par exemple :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
Type foo(void)
{
      if(...)
               return int(2);
      if(....)
               return float(4);
}

EDIT :
Je viens d'y penser mais une solution pourrait aussi �tre :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
struct{
         union{
                    int i;
                    float f;
        }
 
         TypeId id;
}

[guitou99999999]

Merci de vos r�ponses !!

De ce que je comprends il n'y a pas de m�thode simple. Je vais �tudier tout �a !!

[M�dinoc]

C'est le principe du Variant: Une union plus son type.

Je crois que Boost (et peut-�tre m�me C++11) expose un tel template, permettant de faire un variant sur un ensemble de types.