Wie würde man objektorientierten Code in C schreiben? [closed]

Question 1

Welche Möglichkeiten gibt es, objektorientierten Code in C zu schreiben? Vor allem im Hinblick auf Polymorphie.

Siehe auch diese Stack Overflow-Frage Objektorientierung in C.

Question 2

Da Sie über Polymorphismus sprechen, ja, das können Sie, wir haben diese Art von Sachen gemacht, Jahre bevor C++ aufkam.

Grundsätzlich verwendet man a struct um sowohl die Daten als auch eine Liste von Funktionszeigern zu halten, die auf die relevanten Funktionen für diese Daten zeigen.

In einer Kommunikationsklasse hätten Sie also einen Open-, Read-, Write- und Close-Aufruf, der als vier Funktionszeiger in der Struktur neben den Daten für ein Objekt verwaltet würde, etwa so:

typedef struct {
    int (*open)(void *self, char *fspec);
    int (*close)(void *self);
    int (*read)(void *self, void *buff, size_t max_sz, size_t *p_act_sz);
    int (*write)(void *self, void *buff, size_t max_sz, size_t *p_act_sz);
    // And data goes here.
} tCommClass;

tCommClass commRs232;
commRs232.open = &rs232Open;
: :
commRs232.write = &rs232Write;

tCommClass commTcp;
commTcp.open = &tcpOpen;
: :
commTcp.write = &tcpWrite;

Natürlich wären diese obigen Codesegmente tatsächlich in einem “Konstruktor” wie z rs232Init().

Wenn Sie von dieser Klasse „erben“, ändern Sie einfach die Zeiger so, dass sie auf Ihre eigenen Funktionen zeigen. Jeder, der diese Funktionen aufgerufen hat, würde dies über die Funktionszeiger tun und Ihnen Ihren Polymorphismus geben:

int stat = (commTcp.open)(commTcp, "bigiron.box.com:5000");

Art wie eine manuelle vtable.

Sie könnten sogar virtuelle Klassen haben, indem Sie die Zeiger auf NULL setzen – das Verhalten würde sich geringfügig von C++ unterscheiden (ein Core-Dump zur Laufzeit statt eines Fehlers zur Kompilierzeit).

Hier ist ein Beispielcode, der dies demonstriert. Zuerst die Klassenstruktur der obersten Ebene:

#include <stdio.h>

// The top-level class.

typedef struct sCommClass {
    int (*open)(struct sCommClass *self, char *fspec);
} tCommClass;

Dann haben wir die Funktionen für die TCP-‘Unterklasse’:

// Function for the TCP 'class'.

static int tcpOpen (tCommClass *tcp, char *fspec) {
    printf ("Opening TCP: %s\n", fspec);
    return 0;
}
static int tcpInit (tCommClass *tcp) {
    tcp->open = &tcpOpen;
    return 0;
}

Und das HTTP auch:

// Function for the HTTP 'class'.

static int httpOpen (tCommClass *http, char *fspec) {
    printf ("Opening HTTP: %s\n", fspec);
    return 0;
}
static int httpInit (tCommClass *http) {
    http->open = &httpOpen;
    return 0;
}

Und schließlich ein Testprogramm, um es in Aktion zu zeigen:

// Test program.

int main (void) {
    int status;
    tCommClass commTcp, commHttp;

    // Same 'base' class but initialised to different sub-classes.

    tcpInit (&commTcp);
    httpInit (&commHttp);

    // Called in exactly the same manner.

    status = (commTcp.open)(&commTcp, "bigiron.box.com:5000");
    status = (commHttp.open)(&commHttp, "http://www.microsoft.com");

    return 0;
}

Dies erzeugt die Ausgabe:

Opening TCP: bigiron.box.com:5000
Opening HTTP: http://www.microsoft.com

So können Sie sehen, dass je nach Unterklasse unterschiedliche Funktionen aufgerufen werden.

Question 3

Ich glaube, dass die Implementierung von OOP in C nicht nur an sich nützlich ist, sondern auch eine hervorragende Möglichkeit, dies zu tun lernen OOP und sein Innenleben verstehen. Die Erfahrung vieler Programmierer hat gezeigt, dass ein Programmierer verstehen muss, wie die zugrunde liegenden Konzepte letztendlich implementiert werden, um eine Technik effizient und sicher einzusetzen. Das Emulieren von Klassen, Vererbung und Polymorphismus in C lehrt genau das.

Um die ursprüngliche Frage zu beantworten, hier sind ein paar Ressourcen, die zeigen, wie man OOP in C macht:

Der EmbeddedGurus.com-Blogbeitrag „Objektbasierte Programmierung in C“ zeigt, wie Klassen und Einzelvererbung in portablem C implementiert werden:
http://embeddedgurus.com/state-space/2008/01/object-based-programming-in-c/

Application Note „„C+“—Object Oriented Programming in C“ zeigt die Implementierung von Klassen, Einfachvererbung und später Bindung (Polymorphismus) in C mithilfe von Präprozessor-Makros:
http://www.state-machine.com/resources/cplus_3.0_manual.pdfder Beispielcode ist unter verfügbar http://www.state-machine.com/resources/cplus_3.0.zip

Question 4

Ich habe es fertig gesehen. Ich würde es nicht empfehlen. C++ begann auf diese Weise ursprünglich als Präprozessor, der als Zwischenschritt C-Code produzierte.

Im Wesentlichen erstellen Sie eine Dispatch-Tabelle für alle Ihre Methoden, in der Sie Ihre Funktionsreferenzen speichern. Das Ableiten einer Klasse würde das Kopieren dieser Dispatch-Tabelle und das Ersetzen der Einträge, die Sie überschreiben wollten, mit sich bringen, wobei Ihre neuen “Methoden” die ursprüngliche Methode aufrufen müssten, wenn sie die Basismethode aufrufen möchten. Am Ende schreiben Sie C++ neu.

Question 5

Sicher ist das möglich. Das ist was GObjectder Rahmen, der alle GTK+ und Gnom basiert auf, tut.