J'ai découvert qu'on pouvait faire de l'objet en C:
 
http://chgi.developpez.com/c/objet/
http://c.ftp-developpez.com/downloads/c/cobjet.pdf
 
Mais ça m'a l'air pus compliqué (à 1ère vue) qu'en C++. Est-ce que c'est une technique barbare ou est-ce que c'est vraiment efficace quand on est habitué?
 
Merci encore!

Ben c'est pas vraiment compliqué. Il suffit de rajouter aux structures des pointeurs sur des fonctions et ensuite on peut "simuler" l'appel à une fonction membre. Le plus dur est d'écrire toutes les fonctions de manipulation de structures. Une fois ces fonctions écrites, il suffit de les utiliser quand on veut, comme en C++.
On reste quand-même obligé de passer à ces fonctions le pointeur vers l'élément qu'on manipule, chose qui n'est pas à faire en C++.
C'est très certainement efficace sauf que je ne vois pas pourquoi il faudrait s'embêter à simuler de l'objet en C alors qu'on l'a directement en C++...

C'est compliqué si on cherche à reproduire tous les paradigmes objets en C (c'est ce que faisait C-front au temp des débuts héroïques du C++, Google est ton ami). Et c'est pour ça qu'on a inventé des langages qui supportent nativement ces paradigmes (Smalltalk, Objective-C, C++ etc.)
 
Par contre, on peut utiliser une orientation objet simple comme les types abstraits de données. C'est une pratique courante. FILE est un bon exemple dans la bibliothèque standard du  C. La bibliothèque GUI portable GTK+ est un bon exemple d'application des principes OO en C.
 
http://mapage.noos.fr/emdel/tad.htm
 
 
 

Merci pour vos réponses, donc je vais faire un peu de lecture...

En programmant le trie d'une liste chainé, j' ai eu l'impression que le dit C orienté objet n'est qu'une prolongation:
Grace à la déclaration de variable, j'ai réduit le code: des testes on été réduit à un calcule pour la recherche d'une addresse.
à la base, le code se présantait comme ça:
if (a->next && a->next->pos>a->pos)
 while (a->next && a->next->pos>a->pos)
 {
 (on passe des addresses)
  ...
 }
else
 while (a->prev && a->prev->pos>a->pos)
 {  
  (on passe des addresses)
   ...
 }
le code actuel (qui au final est moin claire):
 void
 sort_contents
         (
                 void **h,
                 int (*test)(void *,int),
                 void *(*read_next)(void *),
                 void (*set_next)(void **,void *),
                 void *(*read_prev)(void *),
                 void (*set_prev)(void **,void *)
 )
 {
         void *ph,*after,*p,*pa,*pb;
         void **aptr[5]={&ph,&pa,&pb,&p,&h[0]},
                 **bptr[5]={&ph,&pb,&pa,&p,&h[0]};  
         void **ptrs[2][5]={     {&pa,&ph,&pb,&p,&h[0]},
                                 {&pa,&p,&pb,&ph,&h[0]}};
         void ***plist[2]={aptr,bptr};
         void *(*___read___[2])(void *)={read_prev,read_next};
         void (*set[2])(void **,void *)={set_next,set_prev};
         unsigned short int i,j,tv[2]={3,0};
         int pset;
         ph=h[0];
         while (ph)
         {
                 after=(*read_next)(ph);
                 pset=(*test)(ph,0);
                 while (!(*test)(ph,pset))
                 {
                         for (i=0;i<4;i++)
                                 if (i<2)
                                         plist[pset][1][0]
                                         =(*___read___[1-pset])(plist[pset][i][0]);
                                 else
                                         plist[pset][i][0]
                                         =(*___read___[(i-2)^pset])(plist[pset][0][0]);
                         for (j=0;j<4;j++)
                                 (*set[!(j<2)^pset])(plist[pset][tv[j%2]],plist[pset][j][0]);
                         if (ptrs[pset][0][0])
                                 (*set_prev)(ptrs[pset][0],ptrs[pset][1][0]);
                         if (ptrs[pset][2][0])
                                 (*set_next)(ptrs[pset][2],ptrs[pset][3][0]);
                         else
                                 ptrs[pset][4][0]=ptrs[pset][3][0];
                 }
                 ph=after;
         }
 }
tout découle d'un teste que j'avais réalisé:
 int  
 main(void)
 {
  void *ptr=NULL;
  int v=1;
  printf("%i\n",(!ptr));
  ptr=(void *)&v;
  printf("%i\n",(!ptr));
  return 0;
 }
ce qui donne par exemple:
 (*set[!(j<2)^pset])(plist[pset][tv[j%2]],plist[pset][j][0]);
 
dans l'ensemble le COO consiste à manipuler les objet lvalue (les addresses, qui n'ont pas de type)... les mov remplace les cmp,jz,jnz..

Ce topic a environ 5 ans quand même, et je vois difficilement le rappport avec la question.
Dans ton exemple, pouruoi tu passes tous tes pointeurs de fonction en argument à ta classe ?
Si tu es censé faire de l'OO en C, tu dois aussi avoir un système de vtable sur laquelle ta structure pointe, logiquement, et non pas devoir fournir ton interface méthode par méthode à chaque fonction qui traite tes objets.
Accessoirement, je ne trouve pas un seul lien logique entre le test que tu as réalisé et le code qui est censé en découler

C'était déjà le cas pour son intervention précédente.
A+,

snif...
un arbre à été sauvé...

je suis pas hors sujet, et je me débrouille vraiment pas si mal dans le fond
si tu programme bien alors tu te fou du COO.
 
P.S:Rien empêche de se la péter et faire du CHQ.

une fonction c'est une addresse et une adresse t'y accede de partout pattate.

Si ça continue, on va rapidement atteindre le point de modération...
A+,

 
A te lire on a vraiment l'impression que tu te réponds à toi-même...  

Ou alors avec des membres imaginaires (ce qui pourrait être un concept de POO...).