Wie kann ich Polymorphismus im OO-Stil in C simulieren?

Gibt es eine Möglichkeit, OO-ähnlichen Code in die C Programmiersprache?

Siehe auch:

• Können Sie objektorientierten Code in C schreiben?
• Objektorientierung in C

Gefunden durch Suche auf “[c] oo”.

Der erste C++-Compiler (“C mit Klassen”) würde tatsächlich C-Code generieren, also ist das definitiv machbar.

Grundsätzlich ist Ihre Basisklasse eine Struktur; Abgeleitete Strukturen müssen die Basisstruktur an der ersten Position enthalten, sodass ein Zeiger auf die “abgeleitete” Struktur auch ein gültiger Zeiger auf die Basisstruktur ist.

typedef struct {
   data member_x;
} base;

typedef struct {
   struct base;
   data member_y;
} derived;

void function_on_base(struct base * a); // here I can pass both pointers to derived and to base

void function_on_derived(struct derived * b); // here I must pass a pointer to the derived class

Die Funktionen können als Funktionszeiger Teil der Struktur sein, sodass eine Syntax wie p->call(p) möglich wird, aber Sie müssen immer noch explizit einen Zeiger auf die Struktur an die Funktion selbst übergeben.

Der übliche Ansatz besteht darin, Struct mit Zeigern auf Funktionen zu definieren. Dies definiert “Methoden”, die für jeden Typ aufgerufen werden können. Untertypen legen dann ihre eigenen Funktionen in dieser gemeinsamen Struktur fest und geben sie zurück.

Zum Beispiel gibt es im Linux-Kernel struct:

struct inode_operations {
    int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
    struct dentry * (*lookup) (struct inode *,struct dentry *, 
                               struct nameidata *);
    ...
};

Jeder registrierte Dateisystemtyp registriert dann seine eigenen Funktionen für create, lookup, und verbleibende Funktionen. Der Rest des Codes kann dann generische inode_operations verwenden:

struct inode_operations   *i_op;
i_op -> create(...);

C++ ist nicht so weit von C entfernt.

Klassen sind Strukturen mit einem versteckten Zeiger auf eine Tabelle von Funktionszeigern namens VTable. Die Vtable selbst ist statisch. Wenn Typen auf Vtables mit der gleichen Struktur zeigen, aber Zeiger auf andere Implementierungen zeigen, erhalten Sie Polymorphismus.

Es wird empfohlen, die Aufruflogik in Funktionen zu kapseln, die die Struktur als Parameter verwenden, um Code-Clutter zu vermeiden.

Sie sollten auch die Instantiierung und Initialisierung von Strukturen in Funktionen (dies entspricht einem C++-Konstruktor) und das Löschen (Destruktor in C++) kapseln. Das sind sowieso gute Übungen.

typedef struct
{
   int (*SomeFunction)(TheClass* this, int i);
   void (*OtherFunction)(TheClass* this, char* c);
} VTable;

typedef struct
{
   VTable* pVTable;
   int member;

} TheClass;

So rufen Sie die Methode auf:

int CallSomeFunction(TheClass* this, int i)
{
  (this->pVTable->SomeFunction)(this, i);
}

Ich habe mir die Antworten aller anderen angesehen und bin zu folgendem Ergebnis gekommen:

#include <stdio.h>

typedef struct
{
    int (*get)(void* this);
    void (*set)(void* this, int i);
    int member;

} TheClass;

int Get(void* this)
{
    TheClass* This = (TheClass*)this;
    return This->member;
}

void Set(void* this, int i)
{
    TheClass* This = (TheClass*)this;
    This->member = i;
}

void init(TheClass* this)
{
    this->get = &Get;
    this->set = &Set;
}

int main(int argc, char **argv)
{
    TheClass name;
    init(&name);
    (name.set)(&name, 10);
    printf("%d\n", (name.get)(&name));
    return 0;
}

Ich hoffe das beantwortet einige Fragen.

Anhang B des Artikels Öffnen Sie wiederverwendbare Objektmodellevon Ian Piumarta und Alessandro Warth von VPRI ist eine Implementierung eines Objektmodells in GNU C, etwa 140 Codezeilen. Es ist eine faszinierende Lektüre!

Hier ist die nicht zwischengespeicherte Version des Makros, das Nachrichten an Objekte sendet, indem es eine GNU-Erweiterung für C verwendet (Aussage Ausdruck):

struct object;

typedef struct object *oop; 
typedef oop *(*method_t)(oop receiver, ...);

//...

#define send(RCV, MSG, ARGS...) ({ \ 
    oop r = (oop)(RCV); \ 
    method_t method = _bind(r, (MSG)); \ 
    method(r, ##ARGS); \ 
}) 

Sehen Sie sich im selben Dokument die object, vtable, vtable_delegated und symbol Strukturen und die _bind und vtable_lookup Funktionen.

Prost!

Was ich normalerweise gerne mache, ist, die Strukturen in eine andere zu verpacken, die Metainformationen über die verpackte Klasse enthält, und dann besucherähnliche Funktionslisten zu erstellen, die auf die generische Struktur wirken. Der Vorteil dieses Ansatzes besteht darin, dass Sie die vorhandenen Strukturen nicht ändern müssen und Besucher für jede Teilmenge von Strukturen erstellen können.

Nehmen Sie das übliche Beispiel:

typedef struct {
    char call[7] = "MIAO!\n";
} Cat;
    
typedef struct {
    char call[6] = "BAU!\n";
} Dog;

Wir können die 2 Strukturen in diese neue Struktur einpacken:

typedef struct {
    const void * animal;
    AnimalType type;
} Animal;

Der Typ kann ein einfaches int sein, aber seien wir nicht faul:

typedef enum  {
    ANIMAL_CAT = 0,
    ANIMAL_DOG,
    ANIMAL_COUNT
} AnimalType;

Es wäre schön, einige Wrapping-Funktionen zu haben:

Animal catAsAnimal(const Cat * c) {
    return (Animal){(void *)c, ANIMAL_CAT};
}

Animal dogAsAnimal(const Dog * d) {
    return (Animal){(void *)d, ANIMAL_DOG};
}

Jetzt können wir unseren “Besucher” definieren:

void catCall ( Animal a ) {
    Cat * c = (Cat *)a.animal;
    printf(c->call);
}

void dogCall ( Animal a ) {
    Dog * d = (Dog *)a.animal;
    printf(d->call);
}

void (*animalCalls[ANIMAL_COUNT])(Animal)={&catCall, &dogCall};

Dann wird die tatsächliche Verwendung sein:

Cat cat;
Dog dog;

Animal animals[2];
animals[0] = catAsAnimal(&cat);
animals[1] = dogAsAnimal(&dog);

for (int i = 0; i < 2; i++) {
    Animal a = animals[i];
    animalCalls[a.type](a);
}

Der Nachteil dieses Ansatzes besteht darin, dass Sie die Strukturen jedes Mal umschließen müssen, wenn Sie sie als generischen Typ verwenden möchten.

Die Dateifunktionen fopen, fclose, fread sind Beispiele für OO-Code in C. Anstelle der privaten Daten in der Klasse arbeiten sie an der FILE-Struktur, die zum Einkapseln der Daten verwendet wird, und die C-Funktionen fungieren als Member-Klassenfunktionen. http://www.amazon.com/File-Structures-Object-Oriented-Approach-C/dp/0201874016