Discussion :

[LaMainSurLeKatana]

Bonjour,
je travaille actuellement sur un projet en C/C++ sur lequel je rencontre des problèmes.

En fait j'ai une fonction qui utilise des structures définies comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
struct{
  int id;
  void* value;
}Record
 
struct{
  int id;
  int type;
}Event;

La fonction se définit comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
int fonction(Record* pData)
{
     //Récupération de données
     pData->id = 10;
 
     //Création d'une variable de type Event
     Event event;
     event.id = 2;
     event.type = 5;
}

En fait, je veux dans la fonction ensuite, que le membre de pData, "value", stocke la variable "event". Je pensais utilise "Event*" mais après je sais pas comment effectue le cast avec "void*".
Donc si quelqu’un a une idée. Merci.

[fregolo52]

Tu as un gros problème dans ton code actuel.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Event event;

est locale à la fonction, donc tu vas perdre les info dès que tu vas sortir de la fonction. Il faut allouer soi-même la mémoire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
     //Création d'une variable de type Event
     Event *event = new Event;
     event->id = 2;
     event->type = 5;

Après tu fais un cast :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pData->value = (void *)event;

Et quand tu voudras récupérer tes données tu feras :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Event *event = (Event *)tonRecord->value;

Et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
struct Record{
  int id;
  void* value;
};
 
struct Event{
  int id;
  int type;
};

c'est mieux comme déclaration.

[MacPro]

Il faudra aussi penser à libérer la mémoire allouée dans l'exemple de fregolo52. L'utilisation des static_cast ne fera pas de mal non plus au lieu du C-style cast (cf FAQ ici ).

[Aladore]

C'est du C ou du C++ ?
Si c'est du C++ je te conseille de plutôt passer par des template au lieu d'un pointeur sur void. Enfin après ça dépend ce que tu souhaites faire avec ta structure Record, mais bon.

[loufoque]

Pas besoin de (void*), la conversion T* -> void* est implicite

[Astraya]

a noté que avec void* le cast qui correspondant est le reinterpret_cast en C++.

[Luc Hermitte]

Non. La conversion depuis les void* se fait avec un static_cast.

Et +1 à Aladore. Les templates, c'est bien mieux. Je suis surpris que personne n'aie réagis plus tôt.

[Astraya]

La conversion depuis les void* se fait avec un static_cast.

Depuis oui, je parlais de conversion de void* en autre choses, je n'ai pas été assez précis.

Edit: "en pointeur d'autre chose", le static_cast n'accepteras pas caster vers un pointeur qui n'a rien à voir avec le type pointé demandé.

[Flob90]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
void* p1 = new int();
int* p2 = static_cast<int*>(p1);

Marche très bien. Avoir besoin d'un reinterpret_cast c'est plus rare (quand il n'y a aucun lien entre les types).

[Astraya]

vers un pointeur qui n'a rien à voir avec le type pointé demandé....

[Flob90]

Je ne comprend pas ce que tu veus dire. Les seules données qu'on a c'est le type statique de l'objet à caster (ici void*) et le type vers lequel on veut aller (celui entre <>).

Conversions that can be performed explicitly using reinterpret_cast are listed below. No other conversion can be performed explicitly using reinterpret_cast.

(norme) Et dans la liste je ne vois pas de conversion depuis un pointeur vers un pointeur sur un objet.

Il y a bien un pointeur sur un objet de type T1 vers un pointeur sur un objet de type T2, mais je ne suis pas certain que ca s'applique avec T1 = void et si c'est le cas alors c'est strictement équivalent à un static_cast d'un pointeur vers un pointeur sur un objet de type T2.

Finalement, faire un reinterpret_cast depuis un pointeur (void*) vers un pointeur sur un objet de type T2 (T2*), ie reinterpret_cast<T2*>(p); avec void* le type statique de p, ne sert jamais à rien. (sauf cas spécial où T2* est un type entier)

Si ce n'est pas ce que tu disais, alors je n'ai rien compris à ce que tu as dit.