Comment implémenter une classe en C ?

Question

En supposant que je doive utiliser le langage C (pas de compilateur C++ ou orienté objet) et que je ne dispose pas d'allocation dynamique de mémoire, quelles sont les techniques que je peux utiliser pour implémenter une classe, ou une bonne approximation d'une classe ? Est-ce toujours une bonne idée d'isoler la "classe" dans un fichier séparé ? Supposons que nous puissions préallouer la mémoire en supposant un nombre fixe d'instances, ou même en définissant la référence à chaque objet comme une constante avant la compilation. N'hésitez pas à faire des hypothèses sur le concept de POO que je devrai mettre en œuvre (cela variera) et à suggérer la meilleure méthode pour chacun d'entre eux.

Restrictions :

• Je dois utiliser le C et non un OOP parce que j'écris du code pour un système embarqué, et le compilateur et la base de code préexistante est en C.
• Il n'y a pas d'allocation dynamique de la mémoire car nous n'avons pas assez de mémoire pour supposer raisonnablement que nous n'en manquerons pas si nous commençons à l'allouer dynamiquement la mémoire.
• Les compilateurs avec lesquels nous travaillons n'ont pas de problèmes avec les pointeurs de fonction.

Answer 1

Cela dépend de l'ensemble exact de fonctionnalités "orientées objet" que vous souhaitez avoir. Si vous avez besoin de choses comme la surcharge et/ou les méthodes virtuelles, vous devez probablement inclure les pointeurs de fonction dans les structures :

typedef struct {
  float (*computeArea)(const ShapeClass *shape);
} ShapeClass;

float shape_computeArea(const ShapeClass *shape)
{
  return shape->computeArea(shape);
}

Cela vous permet d'implémenter une classe, en "héritant" de la classe de base, et en implémentant une fonction appropriée :

typedef struct {
  ShapeClass shape;
  float width, height;
} RectangleClass;

static float rectangle_computeArea(const ShapeClass *shape)
{
  const RectangleClass *rect = (const RectangleClass *) shape;
  return rect->width * rect->height;
}

Cela nécessite bien sûr l'implémentation d'un constructeur, qui s'assure que le pointeur de fonction est correctement configuré. Normalement, vous devriez allouer dynamiquement de la mémoire pour l'instance, mais vous pouvez également laisser l'appelant le faire :

void rectangle_new(RectangleClass *rect)
{
  rect->width = rect->height = 0.f;
  rect->shape.computeArea = rectangle_computeArea;
}

Si vous voulez plusieurs constructeurs différents, vous devrez "décorer" les noms des fonctions, vous ne pouvez pas avoir plus d'une fonction. rectangle_new() fonction :

void rectangle_new_with_lengths(RectangleClass *rect, float width, float height)
{
  rectangle_new(rect);
  rect->width = width;
  rect->height = height;
}

Voici un exemple de base montrant l'utilisation :

int main(void)
{
  RectangleClass r1;

  rectangle_new_with_lengths(&r1, 4.f, 5.f);
  printf("rectangle r1's area is %f units square\n", shape_computeArea(&r1));
  return 0;
}

J'espère que cela vous donne quelques idées, au moins. Pour un cadre de travail orienté objet riche et réussi en C, regardez dans glib's Objet GO bibliothèque.

Notez également qu'il n'y a pas de "classe" explicite modélisée ci-dessus, chaque objet possède ses propres pointeurs de méthode, ce qui est un peu plus flexible que ce que l'on trouve généralement en C++. De plus, cela coûte de la mémoire. Vous pourriez éviter cela en plaçant les pointeurs de méthode dans un fichier class et inventer un moyen pour chaque instance d'objet de référencer une classe.

Answer 2

J'ai dû le faire une fois aussi pour un devoir. J'ai suivi cette approche :

1. Définissez vos membres de données dans un struct.
2. Définissez les membres de votre fonction qui prennent un pointeur sur votre structure comme premier argument.
3. Faites-les en une tête et un c. En-tête pour la définition de la structure et déclarations de fonctions, c pour les implémentations.

Un exemple simple serait le suivant :

/// Queue.h
struct Queue
{
    /// members
}
typedef struct Queue Queue;

void push(Queue* q, int element);
void pop(Queue* q);
// etc.
///

Answer 3

Si vous ne voulez qu'une seule classe, utilisez un tableau de struct en tant que données "objets" et passer des pointeurs vers eux aux fonctions "membres". Vous pouvez utiliser typedef struct _whatever Whatever avant de déclarer struct _whatever pour cacher l'implémentation au code client. Il n'y a aucune différence entre un tel "objet" et la bibliothèque standard de C FILE objet.

Si vous voulez plus d'une classe avec héritage et fonctions virtuelles, il est courant d'avoir des pointeurs vers les fonctions comme membres de la structure, ou un pointeur partagé vers une table de fonctions virtuelles. Le site Objet GO utilise à la fois cette astuce et celle du typedef, et est largement utilisée.

Il existe également un livre sur les techniques de ce type disponible en ligne. Programmation orientée objet avec ANSI C .

Answer 4

Vous pouvez jeter un coup d'oeil à GOBject. Il s'agit d'une bibliothèque OS qui vous donne une manière verbeuse de faire un objet.

http://library.gnome.org/devel/gobject/stable/

Answer 5

Miro Samek a développé un framework C orienté objet pour son framework de machine à état : http://sourceforge.net/projects/qpc/ . Et il a aussi écrit un livre à ce sujet : http://www.state-machine.com/psicc2/ .