Discussion :

[muad'dib]

Bonjour à tous,

J'aurais voulu des informations quant à l'implémentation de la notion de polymorphisme en C !

Je sais que le C n'est pas objet ! Que les notions d'héritage n'existent pas. Cependant, j'ai une application client-serveur á développer contenant une centaine de formats de trames différentes. Vous imaginez bien que si je devais créer les 100 structures et à chaque réception ou envoi de paquets analyser et recréer en fonction de, je deviendrais fou !!!

Aussi je ne cherche pas à recréer tout la notion de polymorphisme, mais je voudrais au moins être capable d'avoir une seule méthode pour envoyer les paquet, du genre send_data(objet_englobant paquet).

[zooro]

Bonjour à tous,

J'aurais voulu des informations quant à l'implémentation de la notion de polymorphisme en C !

Je sais que le C n'est pas objet ! Que les notions d'héritage n'existent pas. Cependant, j'ai une application client-serveur á développer contenant une centaine de formats de trames différentes. Vous imaginez bien que si je devais créer les 100 structures et à chaque réception ou envoi de paquets analyser et recréer en fonction de, je deviendrais fou !!!

Aussi je ne cherche pas à recréer tout la notion de polymorphisme, mais je voudrais au moins être capable d'avoir une seule méthode pour envoyer les paquet, du genre send_data(objet_englobant paquet).

Tu pourrais utiliser une union, et par exemple un switch dans send_data qui appellerait ensuite une fonction spécifique au type de trame (send_data_trame1, send_data_trame2, etc.).

[souviron34]

oui moi je ferais assez comme zooro, une union de structures, mais vraisembleblement une fonction "fabrique chaine", dans laquelle il y aurait le switch suivant le type de la structure, qui fabriquerait le tableau de unsigned char à envoyer, puis une bête fonction "send chaine"...

[Foobar1329]

Hello,

Bonjour à tous,

J'aurais voulu des informations quant à l'implémentation de la notion de polymorphisme en C !

Je sais que le C n'est pas objet ! Que les notions d'héritage n'existent pas. Cependant, j'ai une application client-serveur á développer contenant une centaine de formats de trames différentes. Vous imaginez bien que si je devais créer les 100 structures et à chaque réception ou envoi de paquets analyser et recréer en fonction de, je deviendrais fou !!!

Aussi je ne cherche pas à recréer tout la notion de polymorphisme, mais je voudrais au moins être capable d'avoir une seule méthode pour envoyer les paquet, du genre send_data(objet_englobant paquet).

Une union est une solution. Maintenant, il est possible de faire du pseudo-polymorphisme au runtime via des pointeurs vers fonctions. Tu peux créer par exemple une structure contenant le(s) pointeur(s) vers fonction(s), embarquer cette structure dans une autre structure qui serait la "générique" puis dans chaque structure "métier". Voici un petit exemple :

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
typedef struct Frame {
   void (*send_data)();
} Frame_s;
 
typedef struct GenericFrame {
   Frame_s frame; 
} GenericFrame_s;
 
typedef struct FrameA {
   Frame_s frame;
   int n;
} FrameA_s; 
 
typedef struct FrameB {
   Frame_s frame;
   char str[20];
} FrameB_s;
 
typedef struct FrameC {
   Frame_s frame;
   double f;
} FrameC_s;
 
void sendDataFrameA(FrameA_s * frame) {
  printf("I send the frame A with n=%d\n", frame->n);   
}
 
void sendDataFrameB(FrameB_s * frame) {
  printf("I send the frame B with string:%s\n", frame->str);   
}
 
void sendDataFrameC(FrameC_s * frame) {
  printf("I send the frame C with f=%lf\n", frame->f);   
}
 
int main(void)
{
 
  GenericFrame_s * frames[3];
 
  FrameA_s * fA = NULL; 
  FrameB_s * fB = NULL; 
  FrameC_s * fC = NULL; 
 
  int i;
 
  /* TODO : Verifier allocations*/
  fA = malloc(sizeof(*fA));
  fB = malloc(sizeof(*fA));
  fC = malloc(sizeof(*fA)); 
 
  fA->frame.send_data = sendDataFrameA;
  fA->n = 51;
 
  fB->frame.send_data = sendDataFrameB;
  strcpy(fB->str, "hello");
 
  fC->frame.send_data = sendDataFrameC;
  fC->f = 13.2;
 
  frames[0] = (GenericFrame_s*)fA;
  frames[1] = (GenericFrame_s*)fB;
  frames[2] = (GenericFrame_s*)fC;
 
  for(i=0; i<3; ++i) {
    frames[i]->frame.send_data(frames[i]); 
  }    
 
  free(fA);
  free(fB);
  free(fC);
 
  return 0;
}

Pour sélectionner la bonne trame à envoyer, il est possible de définir un identifiant entier dans chaque trame et de s'en servir comme clé dans le tableau les stockant.

A+

[Jean-Marc.Bourguet]

J'aurais voulu des informations quant à l'implémentation de la notion de polymorphisme en C !

Le C ne permet pas d'avoir des conversions implicites définies par l'utilisateur ni de la surcharge.

Le polymorphisme paramétrique (généricité, template) est possible à coup de macros. Si c'est ce que tu veux, cherche generic.h dans de vieille implémentation C++ (si j'ai bonne mémoire, c'est dans g++ 1.X).

Le polymorphisme d'inclusion (la possibilité d'avoir des valeurs ayant plusieurs types) et une surcharge résolue dynamiquement dans ce cadre sont également possible. Pour plus de renseignement, http://ldeniau.web.cern.ch/ldeniau/oopc.html

Suivant le problème, des solutions moins complètes -- mais plus faciles à mettre en oeuvre -- sont possible à coup de void* ou d'union.