Wie implementiert man eine Klasse in C? [closed]

Angenommen, ich muss C verwenden (kein C++ oder objektorientierte Compiler) und ich habe keine dynamische Speicherzuweisung, was sind einige Techniken, die ich verwenden kann, um eine Klasse zu implementieren, oder eine gute Annäherung an eine Klasse? Ist es immer eine gute Idee, die “Klasse” in einer separaten Datei zu isolieren? Angenommen, wir können den Speicher vorab zuweisen, indem wir eine feste Anzahl von Instanzen annehmen oder sogar die Referenz auf jedes Objekt vor der Kompilierzeit als Konstante definieren. Fühlen Sie sich frei, Vermutungen darüber anzustellen, welches OOP-Konzept ich implementieren muss (es wird variieren) und die beste Methode für jedes vorschlagen.

Beschränkungen:

• Ich muss C und kein OOP verwenden, weil ich Code für ein eingebettetes System schreibe und der Compiler und die bereits vorhandene Codebasis in C sind.
• Es gibt keine dynamische Speicherzuweisung, weil wir nicht genug Speicher haben, um davon auszugehen, dass er uns nicht ausgeht, wenn wir mit der dynamischen Zuweisung beginnen.
• Die Compiler, mit denen wir arbeiten, haben keine Probleme mit Funktionszeigern

Das hängt von dem genauen “objektorientierten” Feature-Set ab, das Sie haben möchten. Wenn Sie Dinge wie Überladen und/oder virtuelle Methoden benötigen, müssen Sie wahrscheinlich Funktionszeiger in Strukturen einschließen:

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

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

Auf diese Weise können Sie eine Klasse implementieren, indem Sie die Basisklasse “erben” und eine geeignete Funktion implementieren:

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;
}

Dazu müssen Sie natürlich auch einen Konstruktor implementieren, der dafür sorgt, dass der Funktionszeiger richtig eingerichtet ist. Normalerweise würden Sie der Instanz Speicher dynamisch zuweisen, aber Sie können dies auch dem Aufrufer überlassen:

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

Wenn Sie mehrere verschiedene Konstruktoren möchten, müssen Sie die Funktionsnamen “dekorieren”, Sie können nicht mehr als einen haben rectangle_new() Funktion:

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

Hier ist ein einfaches Beispiel, das die Verwendung zeigt:

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;
}

Ich hoffe, das gibt dir zumindest ein paar Ideen. Für ein erfolgreiches und reichhaltiges objektorientiertes Framework in C schauen Sie sich Glibs an GObject Bibliothek.

Beachten Sie auch, dass oben keine explizite “Klasse” modelliert wird, jedes Objekt hat seine eigenen Methodenzeiger, was etwas flexibler ist, als Sie es normalerweise in C++ finden würden. Außerdem kostet es Speicherplatz. Sie könnten dem entkommen, indem Sie die Methodenzeiger in a stopfen class Struktur und erfinde einen Weg für jede Objektinstanz, auf eine Klasse zu verweisen.

Ich musste es auch einmal für eine Hausaufgabe machen. Ich bin diesem Ansatz gefolgt:

1. Definieren Sie Ihre Datenelemente in einer Struktur.
2. Definieren Sie Ihre Funktionsmitglieder, die als erstes Argument einen Zeiger auf Ihre Struktur annehmen.
3. Tun Sie dies in einem Header und einem c. Header für Strukturdefinitionen und Funktionsdeklarationen, c für Implementierungen.

Ein einfaches Beispiel wäre dieses:

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

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

Wenn Sie nur eine Klasse möchten, verwenden Sie ein Array von structs als die „Objekte“-Daten und übergeben Zeiger darauf an die „Member“-Funktionen. Sie können verwenden typedef struct _whatever Whatever vor der Deklaration struct _whatever um die Implementierung vor dem Client-Code zu verbergen. Es gibt keinen Unterschied zwischen einem solchen “Objekt” und der C-Standardbibliothek FILE Objekt.

Wenn Sie mehr als eine Klasse mit Vererbung und virtuellen Funktionen wünschen, ist es üblich, Zeiger auf die Funktionen als Mitglieder der Struktur oder einen gemeinsam genutzten Zeiger auf eine Tabelle mit virtuellen Funktionen zu haben. Das GObject Die Bibliothek verwendet sowohl diesen als auch den Typedef-Trick und ist weit verbreitet.

Es gibt auch ein Buch über Techniken dafür, das online verfügbar ist – Objektorientierte Programmierung mit ANSI C.

C Schnittstellen und Implementierungen: Techniken zum Erstellen wiederverwendbarer Software, David R. Hanson

http://www.informit.com/store/product.aspx?isbn=0201498413

Dieses Buch erfüllt Ihre Frage hervorragend. Es ist in der Addison Wesley Professional Computing-Serie.

Das grundlegende Paradigma ist in etwa so:

/* for data structure foo */

FOO *myfoo;
myfoo = foo_create(...);
foo_something(myfoo, ...);
myfoo = foo_append(myfoo, ...);
foo_delete(myfoo);

Sie können sich GOBject ansehen. Es ist eine Betriebssystembibliothek, die Ihnen eine ausführliche Möglichkeit bietet, ein Objekt zu bearbeiten.

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

Ich werde ein einfaches Beispiel dafür geben, wie OOP in C durchgeführt werden sollte. Mir ist klar, dass dieser Thread aus dem Jahr 2009 stammt, aber ich möchte ihn trotzdem hinzufügen.

/// Object.h
typedef struct Object {
    uuid_t uuid;
} Object;

int Object_init(Object *self);
uuid_t Object_get_uuid(Object *self);
int Object_clean(Object *self);

/// Person.h
typedef struct Person {
    Object obj;
    char *name;
} Person;

int Person_init(Person *self, char *name);
int Person_greet(Person *self);
int Person_clean(Person *self);

/// Object.c
#include "object.h"

int Object_init(Object *self)
{
    self->uuid = uuid_new();

    return 0;
}
uuid_t Object_get_uuid(Object *self)
{ // Don't actually create getters in C...
    return self->uuid;
}
int Object_clean(Object *self)
{
    uuid_free(self->uuid);

    return 0;
}

/// Person.c
#include "person.h"

int Person_init(Person *self, char *name)
{
    Object_init(&self->obj); // Or just Object_init(&self);
    self->name = strdup(name);

    return 0;
}
int Person_greet(Person *self)
{
    printf("Hello, %s", self->name);

    return 0;
}
int Person_clean(Person *self)
{
    free(self->name);
    Object_clean(self);

    return 0;
}

/// main.c
int main(void)
{
    Person p;

    Person_init(&p, "John");
    Person_greet(&p);
    Object_get_uuid(&p); // Inherited function
    Person_clean(&p);

    return 0;
}

Das grundlegende Konzept besteht darin, die „geerbte Klasse“ an der Spitze der Struktur zu platzieren. Auf diese Weise greift der Zugriff auf die ersten 4 Bytes in der Struktur auch auf die ersten 4 Bytes in der „geerbten Klasse“ zu (unter der Annahme nicht verrückter Optimierungen). Wenn nun der Zeiger der Struktur auf die „geerbte Klasse“ umgewandelt wird, kann die „geerbte Klasse“ auf die „geerbten Werte“ auf die gleiche Weise zugreifen, wie sie normalerweise auf ihre Mitglieder zugreifen würde.

Dies und einige Namenskonventionen für Konstruktoren, Destruktoren, Zuweisungs- und Freigabefunktionen (ich empfehle init, clean, new, free) werden Sie weit bringen.

Verwenden Sie wie bei virtuellen Funktionen Funktionszeiger in der Struktur, möglicherweise mit Class_func(…); Verpackung auch. Fügen Sie für (einfache) Vorlagen einen size_t-Parameter hinzu, um die Größe zu bestimmen, verlangen Sie einen void*-Zeiger oder verlangen Sie einen Klassentyp mit genau der Funktionalität, die Ihnen wichtig ist. (z. B. int GetUUID(Object *self); GetUUID(&p);)

Verwenden ein struct um die Datenmember einer Klasse zu simulieren. In Bezug auf den Methodenumfang können Sie private Methoden simulieren, indem Sie die Privatgelände Funktionsprototypen in der .c-Datei und der Öffentlichkeit Funktionen in der .h-Datei.