Discussion :

[Franck.H]

Je cherche une solution pour un problème sur lequel je tourne un peu en rond, j'explique...

J'ai une liste de type BList dans laquelle, chaque noeud possède un pointeur void * p_user_data, jusque là tout est clair ?

Ok passons aux choses sérieuses... Supposons que ce pointeur pointe sur un objet de type BOject.

J'aimerais savoir, sil y a un moyen quelconque, ou une astuce pour comparer ce pointeur p_user_data pour déterminer s'il est du type BOject ?

[kwariz]

Bonjour,

réponse courte : non.
void* gomme tout, ce n'est plus qu'une adresse sans information de type. Si on te donne un void* tu ne pourras jamais savoir quel en était le type (pour autant qu'il y ait eu un type ce qui n'est pas obligatoire) des données pointées.
Sauf si à la conception tu prévois une gestion personnalisée des types ...

[Franck.H]

Moui.... En fait, mon problème est là, j'ai ma liste, des noeuds pouvant contenir différents type d'objet et si lors du parcours de fermeture de ma liste, un objet de type BOject est stocké, j'appel sa propre fonction de destruction avant de détruire le noeud de la liste.

Je pense alors que le seul moyen est d'ajouter un membre dans la liste permettant de déterminer le type de l'objet stocké à la création de cet objet et de son ajout à la liste.

Cela dit, j'aurais préféré que la liste reste le plus simple et générique possible

[Franck.H]

Sauf si à la conception tu prévois une gestion personnalisée des types ...

C'est encore possible je ne suis qu'au début de mon code mais je ne vois pas trop comment faire cela à vrai dire

[kwariz]

Classiquement en C une liste générique correspond principalement à une liste d'objets de même type. Au besoin tu l'utilises pour avoir une liste d'entiers ou de pointeurs vers des structures de type fixe, rarement tu vas mélanger les types.
Ensuite tu as deux approches :

soit tu gardes le type dans ton noeud avec un enum ou une simple chaine (un peu à la printf)

Code :

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

1
2
3
4
5
6
7
 
enum type { T_INT, T_DOUBLE, ..., T_STRUCT_MACHIN, ... };
struct node {
  enum type data_type; //décrit le type pointé par data
  void* data;
  struct node* next;
}

ou

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
struct node {
  char* data_type;
  void* data;
  struct node* next;
}
 
...
  if (strcmp(current_node->data_type,"BObject")==0) {
   BObject* o=(BObject *) current_node->data;
    ...
  }

Soit tu t'arranges pour mimer des mécanismes à la c++ en ne créant que des listes de données pouvant être castés dans un type commun qui lui contient des infos sur le type réel, éventuellement des pointeurs de fonctions qui assurent la création, la suppression, etc ...

[Franck.H]

Classiquement en C une liste générique correspond principalement à une liste d'objets de même type. Au besoin tu l'utilises pour avoir une liste d'entiers ou de pointeurs vers des structures de type fixe, rarement tu vas mélanger les types.

Oui je sais mais là je sort un peu des sentiers battus. Je ne peut pas faire une liste pas type d'objets, c'est inconcevable et ce serait trop de boulot

Soit tu t'arranges pour mimer des mécanismes à la c++ en ne créant que des listes de données pouvant être castés dans un type commun qui lui contient des infos sur le type réel, éventuellement des pointeurs de fonctions qui assurent la création, la suppression, etc ...

Là franchement tu me pose une colle (ne connaissant pas le C++ ou que très peu) Tu aurait un exemple de ce que fait le C++ ?

[Franck.H]

Ce que je peut éventuellement faire pour que ce soit pas un trop gros bordel sans nom, c'est de changer le type du pointeur des noeuds de la liste par le type BOject, étant donné que ca va être le type de base de presque toute la seconde couche. Je garde un ou deux pointeurs void * comme réservation pour d'éventuels stockage mais au moins je peut tester si l'objet à l'intérieur du noeud existe alors le supprimer.

Je pense que ca reste la meilleure solution pour mon cas

[kwariz]

c++ possède un opérateur typeid qui peut te donner des renseignement sur le type mais je ne suis absolument pas un pro de c++
En revanche tu peux créer une sorte d'héritage, j'ai répondu il y a quelques temps à une question de ce genre : Spécialiser une structure à partir d'une structure existante, possible ?

En gros tu aurais une structure de base :

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
30
31
32
33
34
35
36
struct BObject {
  char* type_name;
  void (*destructor)(struct BObject *);
  /* autres données ou fonctions utiles */
}
 
struct Machin {
  struct BObject obj_info;
  /* Tout le reste de ta structure */
}
 
...
 
struct Machin* creer_machin(...)
{
  struct Machin tmp=malloc(sizeof(*tmp));
  tmp->obj_info=creer_object("Machin", free);
  ...
  return tmp;
}
 
const char* get_type(const struct BObject* obj)
{
  return obj->type_name;
}
 
...
{
  struct Machin machin=creer_machin(...);
  ...
  /* Affichera Machin */
  printf("Type : %s\n", get_type( (const struct BObject*) machin);
  ...
  /* liberera machin */
  machin->Destructor(machin);
}

Mais bon, l'ébauche de code est tapée à la volée et est donné sans garanties ... ça va vite se compliquer ...
Si tu veux un aperçu de cette approche qui est correctement implémentée (avec rigueur et qui est non seulement utilisé mais utile) tu peux consulter GObject, GLib (et d'une manière générale tout se qui se rattache*au projet GTK+).