Objektorientierung in C.

Was wäre eine Reihe von raffinierten Präprozessor-Hacks (ANSI C89 / ISO C90-kompatibel), die eine hässliche (aber verwendbare) Objektorientierung in C ermöglichen?

Ich bin mit einigen verschiedenen objektorientierten Sprachen vertraut. Antworten Sie daher bitte nicht mit Antworten wie "Learn C ++!". Ich habe " Objektorientierte Programmierung mit ANSI C " (Vorsicht: PDF-Format ) und einige andere interessante Lösungen gelesen , aber ich interessiere mich hauptsächlich für Ihre :-)!

Siehe auch Können Sie objektorientierten Code in C schreiben?

C Object System (COS) klingt vielversprechend (es ist immer noch in der Alpha-Version). Aus Gründen der Einfachheit und Flexibilität wird versucht, die verfügbaren Konzepte auf ein Minimum zu beschränken: einheitliche objektorientierte Programmierung, einschließlich offener Klassen, Metaklassen, Eigenschaftsmetaklassen, Generika, Multimethoden, Delegierung, Eigentum, Ausnahmen, Verträge und Schließungen. Es gibt einen Entwurf (PDF), der dies beschreibt.

Ausnahme in C ist eine C89-Implementierung des TRY-CATCH-ENDLICH in anderen OO-Sprachen. Es kommt mit einer Testsuite und einigen Beispielen.

Beide von Laurent Deniau, an dem viel gearbeitet wird OOP in C arbeitet .

Ich würde von der Verwendung von Präprozessoren (ab) abraten, um zu versuchen, die C-Syntax der einer anderen objektorientierteren Sprache ähnlicher zu machen. Auf der einfachsten Ebene verwenden Sie einfach einfache Strukturen als Objekte und geben sie durch Zeiger weiter:

struct monkey
{
    float age;
    bool is_male;
    int happiness;
};

void monkey_dance(struct monkey *monkey)
{
    /* do a little dance */
}

Um Dinge wie Vererbung und Polymorphismus zu bekommen, muss man etwas härter arbeiten. Sie können die manuelle Vererbung durchführen, indem Sie das erste Mitglied einer Struktur als Instanz der Oberklasse festlegen und dann Zeiger auf Basisklassen und abgeleitete Klassen frei umwandeln:

struct base
{
    /* base class members */
};

struct derived
{
    struct base super;
    /* derived class members */
};

struct derived d;
struct base *base_ptr = (struct base *)&d;  // upcast
struct derived *derived_ptr = (struct derived *)base_ptr;  // downcast

Um Polymorphismus (dh virtuelle Funktionen) zu erhalten, verwenden Sie Funktionszeiger und optional Funktionszeigertabellen, die auch als virtuelle Tabellen oder vtables bezeichnet werden:

struct base;
struct base_vtable
{
    void (*dance)(struct base *);
    void (*jump)(struct base *, int how_high);
};

struct base
{
    struct base_vtable *vtable;
    /* base members */
};

void base_dance(struct base *b)
{
    b->vtable->dance(b);
}

void base_jump(struct base *b, int how_high)
{
    b->vtable->jump(b, how_high);
}

struct derived1
{
    struct base super;
    /* derived1 members */
};

void derived1_dance(struct derived1 *d)
{
    /* implementation of derived1's dance function */
}

void derived1_jump(struct derived1 *d, int how_high)
{
    /* implementation of derived 1's jump function */
}

/* global vtable for derived1 */
struct base_vtable derived1_vtable =
{
    &derived1_dance, /* you might get a warning here about incompatible pointer types */
    &derived1_jump   /* you can ignore it, or perform a cast to get rid of it */
};

void derived1_init(struct derived1 *d)
{
    d->super.vtable = &derived1_vtable;
    /* init base members d->super.foo */
    /* init derived1 members d->foo */
}

struct derived2
{
    struct base super;
    /* derived2 members */
};

void derived2_dance(struct derived2 *d)
{
    /* implementation of derived2's dance function */
}

void derived2_jump(struct derived2 *d, int how_high)
{
    /* implementation of derived2's jump function */
}

struct base_vtable derived2_vtable =
{
   &derived2_dance,
   &derived2_jump
};

void derived2_init(struct derived2 *d)
{
    d->super.vtable = &derived2_vtable;
    /* init base members d->super.foo */
    /* init derived1 members d->foo */
}

int main(void)
{
    /* OK!  We're done with our declarations, now we can finally do some
       polymorphism in C */
    struct derived1 d1;
    derived1_init(&d1);

    struct derived2 d2;
    derived2_init(&d2);

    struct base *b1_ptr = (struct base *)&d1;
    struct base *b2_ptr = (struct base *)&d2;

    base_dance(b1_ptr);  /* calls derived1_dance */
    base_dance(b2_ptr);  /* calls derived2_dance */

    base_jump(b1_ptr, 42);  /* calls derived1_jump */
    base_jump(b2_ptr, 42);  /* calls derived2_jump */

    return 0;
}

Und so macht man Polymorphismus in C. Es ist nicht schön, aber es macht den Job. Es gibt einige Probleme mit Zeigerumwandlungen zwischen Basis- und abgeleiteten Klassen, die sicher sind, solange die Basisklasse das erste Mitglied der abgeleiteten Klasse ist. Die Mehrfachvererbung ist viel schwieriger. In diesem Fall müssen Sie Ihre Zeiger manuell anpassen, um zwischen anderen Basisklassen als der ersten zu wechseln. Dies ist sehr schwierig und fehleranfällig.

Eine andere (knifflige) Sache, die Sie tun können, ist, den dynamischen Typ eines Objekts zur Laufzeit zu ändern! Sie weisen ihm einfach einen neuen vtable-Zeiger zu. Sie können sogar einige der virtuellen Funktionen selektiv ändern, während andere beibehalten werden, wodurch neue Hybridtypen erstellt werden. Achten Sie nur darauf, eine neue vtable zu erstellen, anstatt die globale vtable zu ändern. Andernfalls wirken Sie sich versehentlich auf alle Objekte eines bestimmten Typs aus.

Ich habe einmal mit einer C-Bibliothek gearbeitet, die auf eine Weise implementiert wurde, die mir sehr elegant erschien. Sie hatten in C eine Möglichkeit geschrieben, Objekte zu definieren und dann von ihnen zu erben, sodass sie so erweiterbar waren wie ein C ++ - Objekt. Die Grundidee war folgende:

• Jedes Objekt hatte eine eigene Datei
• Öffentliche Funktionen und Variablen werden in der .h-Datei für ein Objekt definiert
• Private Variablen und Funktionen befanden sich nur in der C-Datei
• Um zu "erben", wird eine neue Struktur erstellt, wobei das erste Mitglied der Struktur das Objekt ist, von dem geerbt werden soll

Das Erben ist schwer zu beschreiben, aber im Grunde war es das Folgende:

struct vehicle {
   int power;
   int weight;
}

Dann in einer anderen Datei:

struct van {
   struct vehicle base;
   int cubic_size;
}

Dann könnten Sie einen Van im Speicher erstellen lassen, der von Code verwendet wird, der nur über Fahrzeuge Bescheid weiß:

struct van my_van;
struct vehicle *something = &my_van;
vehicle_function( something );

Es hat wunderbar funktioniert und die .h-Dateien haben genau definiert, was Sie mit jedem Objekt tun können sollen.

Der GNOME-Desktop für Linux ist in objektorientiertem C geschrieben und verfügt über ein Objektmodell namens " GObject ", das Eigenschaften, Vererbung, Polymorphismus sowie einige andere Extras wie Referenzen, Ereignisbehandlung (als "Signale" bezeichnet) und Laufzeit unterstützt Eingabe, private Daten usw.

Es enthält Präprozessor-Hacks, mit denen Sie beispielsweise in der Klassenhierarchie typisieren usw. Hier ist eine Beispielklasse, die ich für GNOME geschrieben habe (Dinge wie gchar sind typedefs):

Klassenquelle

Klassenkopf

Innerhalb der GObject-Struktur gibt es eine GType-Ganzzahl, die als magische Zahl für das dynamische Typisierungssystem von GLib verwendet wird (Sie können die gesamte Struktur in einen "GType" umwandeln, um den Typ zu finden).

Ich habe so etwas in C gemacht, bevor ich wusste, was OOP ist.

Es folgt ein Beispiel, das einen Datenpuffer implementiert, der bei Bedarf bei einer minimalen Größe, einem Inkrement und einer maximalen Größe wächst. Diese spezielle Implementierung basierte auf "Elementen", dh sie wurde entwickelt, um eine listenartige Sammlung eines beliebigen C-Typs zu ermöglichen, nicht nur einen Byte-Puffer variabler Länge.

Die Idee ist, dass das Objekt mit xxx_crt () instanziiert und mit xxx_dlt () gelöscht wird. Jede der "Mitglied" -Methoden benötigt einen speziell eingegebenen Zeiger, um damit zu arbeiten.

Auf diese Weise habe ich eine verknüpfte Liste, einen zyklischen Puffer und eine Reihe anderer Dinge implementiert.

Ich muss gestehen, ich habe nie darüber nachgedacht, wie Vererbung mit diesem Ansatz implementiert werden kann. Ich stelle mir vor, dass eine Mischung aus dem von Kieveli angebotenen ein guter Weg sein könnte.

dtb.c:

#include <limits.h>
#include <string.h>
#include <stdlib.h>

static void dtb_xlt(void *dst, const void *src, vint len, const byte *tbl);

DTABUF *dtb_crt(vint minsiz,vint incsiz,vint maxsiz) {
    DTABUF          *dbp;

    if(!minsiz) { return NULL; }
    if(!incsiz)                  { incsiz=minsiz;        }
    if(!maxsiz || maxsiz<minsiz) { maxsiz=minsiz;        }
    if(minsiz+incsiz>maxsiz)     { incsiz=maxsiz-minsiz; }
    if((dbp=(DTABUF*)malloc(sizeof(*dbp))) == NULL) { return NULL; }
    memset(dbp,0,sizeof(*dbp));
    dbp->min=minsiz;
    dbp->inc=incsiz;
    dbp->max=maxsiz;
    dbp->siz=minsiz;
    dbp->cur=0;
    if((dbp->dta=(byte*)malloc((vuns)minsiz)) == NULL) { free(dbp); return NULL; }
    return dbp;
    }

DTABUF *dtb_dlt(DTABUF *dbp) {
    if(dbp) {
        free(dbp->dta);
        free(dbp);
        }
    return NULL;
    }

vint dtb_adddta(DTABUF *dbp,const byte *xlt256,const void *dtaptr,vint dtalen) {
    if(!dbp) { errno=EINVAL; return -1; }
    if(dtalen==-1) { dtalen=(vint)strlen((byte*)dtaptr); }
    if((dbp->cur + dtalen) > dbp->siz) {
        void        *newdta;
        vint        newsiz;

        if((dbp->siz+dbp->inc)>=(dbp->cur+dtalen)) { newsiz=dbp->siz+dbp->inc; }
        else                                       { newsiz=dbp->cur+dtalen;   }
        if(newsiz>dbp->max) { errno=ETRUNC; return -1; }
        if((newdta=realloc(dbp->dta,(vuns)newsiz))==NULL) { return -1; }
        dbp->dta=newdta; dbp->siz=newsiz;
        }
    if(dtalen) {
        if(xlt256) { dtb_xlt(((byte*)dbp->dta+dbp->cur),dtaptr,dtalen,xlt256); }
        else       { memcpy(((byte*)dbp->dta+dbp->cur),dtaptr,(vuns)dtalen);   }
        dbp->cur+=dtalen;
        }
    return 0;
    }

static void dtb_xlt(void *dst,const void *src,vint len,const byte *tbl) {
    byte            *sp,*dp;

    for(sp=(byte*)src,dp=(byte*)dst; len; len--,sp++,dp++) { *dp=tbl[*sp]; }
    }

vint dtb_addtxt(DTABUF *dbp,const byte *xlt256,const byte *format,...) {
    byte            textÝ501¨;
    va_list         ap;
    vint            len;

    va_start(ap,format); len=sprintf_len(format,ap)-1; va_end(ap);
    if(len<0 || len>=sizeof(text)) { sprintf_safe(text,sizeof(text),"STRTOOLNG: %s",format); len=(int)strlen(text); }
    else                           { va_start(ap,format); vsprintf(text,format,ap); va_end(ap);                     }
    return dtb_adddta(dbp,xlt256,text,len);
    }

vint dtb_rmvdta(DTABUF *dbp,vint len) {
    if(!dbp) { errno=EINVAL; return -1; }
    if(len > dbp->cur) { len=dbp->cur; }
    dbp->cur-=len;
    return 0;
    }

vint dtb_reset(DTABUF *dbp) {
    if(!dbp) { errno=EINVAL; return -1; }
    dbp->cur=0;
    if(dbp->siz > dbp->min) {
        byte *newdta;
        if((newdta=(byte*)realloc(dbp->dta,(vuns)dbp->min))==NULL) {
            free(dbp->dta); dbp->dta=null; dbp->siz=0;
            return -1;
            }
        dbp->dta=newdta; dbp->siz=dbp->min;
        }
    return 0;
    }

void *dtb_elmptr(DTABUF *dbp,vint elmidx,vint elmlen) {
    if(!elmlen || (elmidx*elmlen)>=dbp->cur) { return NULL; }
    return ((byte*)dbp->dta+(elmidx*elmlen));
    }

dtb.h

typedef _Packed struct {
    vint            min;                /* initial size                       */
    vint            inc;                /* increment size                     */
    vint            max;                /* maximum size                       */
    vint            siz;                /* current size                       */
    vint            cur;                /* current data length                */
    void            *dta;               /* data pointer                       */
    } DTABUF;

#define dtb_dtaptr(mDBP)                (mDBP->dta)
#define dtb_dtalen(mDBP)                (mDBP->cur)

DTABUF              *dtb_crt(vint minsiz,vint incsiz,vint maxsiz);
DTABUF              *dtb_dlt(DTABUF *dbp);
vint                dtb_adddta(DTABUF *dbp,const byte *xlt256,const void *dtaptr,vint dtalen);
vint                dtb_addtxt(DTABUF *dbp,const byte *xlt256,const byte *format,...);
vint                dtb_rmvdta(DTABUF *dbp,vint len);
vint                dtb_reset(DTABUF *dbp);
void                *dtb_elmptr(DTABUF *dbp,vint elmidx,vint elmlen);

PS: vint war einfach ein typedef von int - ich habe es verwendet, um mich daran zu erinnern, dass seine Länge von Plattform zu Plattform (für die Portierung) variabel war.

Etwas abseits des Themas, aber der ursprüngliche C ++ - Compiler Cfront kompilierte C ++ zu C und dann zu Assembler.

Konservierte hier .

Wenn Sie Methoden, die für Objekte aufgerufen werden, als statische Methoden betrachten, die ein implizites ' this' an die Funktion übergeben, kann dies das Denken von OO in C erleichtern.

Beispielsweise:

String s = "hi";
System.out.println(s.length());

wird:

string s = "hi";
printf(length(s)); // pass in s, as an implicit this

Oder etwas ähnliches.

ffmpeg (ein Toolkit für die Videoverarbeitung) ist in reinem C (und Assemblersprache) geschrieben, verwendet jedoch einen objektorientierten Stil. Es ist voll von Strukturen mit Funktionszeigern. Es gibt eine Reihe von Factory-Funktionen, die die Strukturen mit den entsprechenden "Methoden" -Zeigern initialisieren.

Wenn Sie wirklich catefully, auch Standard - C - Bibliothek verwendet OOP denken - prüfen , FILE *als Beispiel: fopen()initialisiert ein FILE *Objekt, und verwenden Sie es verwendet , Mitglied Methoden fscanf(), fprintf(), fread(), fwrite()und andere, und schließlich zum Abschluss bringt es mit fclose().

Sie können auch den Pseudo-Objective-C-Weg wählen, der ebenfalls nicht schwierig ist:

typedef void *Class;

typedef struct __class_Foo
{
    Class isa;
    int ivar;
} Foo;

typedef struct __meta_Foo
{
    Foo *(*alloc)(void);
    Foo *(*init)(Foo *self);
    int (*ivar)(Foo *self);
    void (*setIvar)(Foo *self);
} meta_Foo;

meta_Foo *class_Foo;

void __meta_Foo_init(void) __attribute__((constructor));
void __meta_Foo_init(void)
{
    class_Foo = malloc(sizeof(meta_Foo));
    if (class_Foo)
    {
        class_Foo = {__imp_Foo_alloc, __imp_Foo_init, __imp_Foo_ivar, __imp_Foo_setIvar};
    }
}

Foo *__imp_Foo_alloc(void)
{
    Foo *foo = malloc(sizeof(Foo));
    if (foo)
    {
        memset(foo, 0, sizeof(Foo));
        foo->isa = class_Foo;
    }
    return foo;
}

Foo *__imp_Foo_init(Foo *self)
{
    if (self)
    {
        self->ivar = 42;
    }
    return self;
}
// ...

Benutzen:

int main(void)
{
    Foo *foo = (class_Foo->init)((class_Foo->alloc)());
    printf("%d\n", (foo->isa->ivar)(foo)); // 42
    foo->isa->setIvar(foo, 60);
    printf("%d\n", (foo->isa->ivar)(foo)); // 60
    free(foo);
}

Dies kann sich aus einem solchen Objective-C-Code ergeben, wenn ein ziemlich alter Objective-C-zu-C-Übersetzer verwendet wird:

@interface Foo : NSObject
{
    int ivar;
}
- (int)ivar;
- (void)setIvar:(int)ivar;
@end

@implementation Foo
- (id)init
{
    if (self = [super init])
    {
        ivar = 42;
    }
    return self;
}
@end

int main(void)
{
    Foo *foo = [[Foo alloc] init];
    printf("%d\n", [foo ivar]);
    [foo setIvar:60];
    printf("%d\n", [foo ivar]);
    [foo release];
}

Ich denke, was Adam Rosenfield gepostet hat, ist die richtige Art, OOP in C zu machen. Ich möchte hinzufügen, dass das, was er zeigt, die Implementierung des Objekts ist. Mit anderen Worten, die eigentliche Implementierung würde in die .cDatei eingefügt, während die Schnittstelle in die Header- .hDatei eingefügt würde . Verwenden Sie zum Beispiel das obige Affenbeispiel:

Die Schnittstelle würde folgendermaßen aussehen:

//monkey.h

    struct _monkey;

    typedef struct _monkey monkey;

    //memory management
    monkey * monkey_new();
    int monkey_delete(monkey *thisobj);
    //methods
    void monkey_dance(monkey *thisobj);

Sie können in der Schnittstellendatei sehen .h, dass Sie nur Prototypen definieren. Anschließend können Sie den Implementierungsteil " .cDatei" in eine statische oder dynamische Bibliothek kompilieren . Dadurch wird eine Kapselung erstellt, und Sie können die Implementierung nach Belieben ändern. Der Benutzer Ihres Objekts muss fast nichts über die Implementierung wissen. Dies konzentriert sich auch auf das Gesamtdesign des Objekts.

Ich bin der persönlichen Überzeugung, dass oop eine Möglichkeit ist, Ihre Codestruktur und Wiederverwendbarkeit zu konzipieren, und wirklich nichts mit den anderen Dingen zu tun hat, die zu C ++ hinzugefügt werden, wie Überladen oder Vorlagen. Ja, das sind sehr nette nützliche Funktionen, aber sie sind nicht repräsentativ dafür, was objektorientierte Programmierung wirklich ist.

Meine Empfehlung: Halte es einfach. Eines der größten Probleme, das ich habe, ist die Wartung älterer Software (manchmal über 10 Jahre alt). Wenn der Code nicht einfach ist, kann es schwierig sein. Ja, man kann sehr nützliches OOP mit Polymorphismus in C schreiben, aber es kann schwierig zu lesen sein.

Ich bevorzuge einfache Objekte, die eine genau definierte Funktionalität enthalten. Ein gutes Beispiel hierfür ist GLIB2 , zum Beispiel eine Hash-Tabelle:

GHastTable* my_hash = g_hash_table_new(g_str_hash, g_str_equal);
int size = g_hash_table_size(my_hash);
...

g_hash_table_remove(my_hash, some_key);

Die Schlüssel sind:

1. Einfache Architektur und Designmuster
2. Erreicht eine grundlegende OOP-Kapselung.
3. Einfach zu implementieren, zu lesen, zu verstehen und zu warten

Wenn ich OOP in CI schreiben würde, würde ich wahrscheinlich ein Pseudo- Pimpl- Design verwenden. Anstatt Zeiger an Strukturen zu übergeben, übergeben Sie am Ende Zeiger an Zeiger an Strukturen. Dies macht den Inhalt undurchsichtig und erleichtert Polymorphismus und Vererbung.

Das eigentliche Problem mit OOP in C ist, was passiert, wenn Variablen den Gültigkeitsbereich verlassen. Es gibt keine vom Compiler generierten Destruktoren, was zu Problemen führen kann. Makros können möglicherweise helfen, aber es wird immer hässlich anzusehen sein.

Eine andere Möglichkeit, mit C in einem objektorientierten Stil zu programmieren, besteht darin, einen Codegenerator zu verwenden, der eine domänenspezifische Sprache in C umwandelt. Wie bei TypeScript und JavaScript, um OOP auf js zu bringen.

#include "triangle.h"
#include "rectangle.h"
#include "polygon.h"

#include <stdio.h>

int main()
{
    Triangle tr1= CTriangle->new();
    Rectangle rc1= CRectangle->new();

    tr1->width= rc1->width= 3.2;
    tr1->height= rc1->height= 4.1;

    CPolygon->printArea((Polygon)tr1);

    printf("\n");

    CPolygon->printArea((Polygon)rc1);
}

Ausgabe:

6.56
13.12

Hier ist eine Show, was OO-Programmierung mit C ist.

Dies ist echtes, reines C, keine Präprozessormakros. Wir haben Vererbung, Polymorphismus und Datenkapselung (einschließlich Daten, die für Klassen oder Objekte privat sind). Es gibt keine Chance für ein geschütztes Qualifikationsäquivalent, dh private Daten sind auch in der Vererbungskette privat. Dies ist jedoch keine Unannehmlichkeit, da ich dies nicht für notwendig halte.

CPolygon wird nicht instanziiert, weil wir es nur verwenden, um Objekte entlang der Vererbungskette zu manipulieren, die gemeinsame Aspekte haben, diese aber unterschiedlich implementieren (Polymorphismus).

@Adam Rosenfield hat eine sehr gute Erklärung, wie man mit C OOP erreicht

Außerdem würde ich Ihnen empfehlen, zu lesen

1) pjsip

Eine sehr gute C-Bibliothek für VoIP. Sie können lernen, wie OOP durch Strukturen und Funktionszeigertabellen erreicht wird

2) iOS-Laufzeit

Erfahren Sie, wie iOS Runtime Ziel C unterstützt. Es erreicht OOP durch einen Zeiger, eine Metaklasse

Für mich sollte die Objektorientierung in C folgende Merkmale haben:

1. Kapselung und Ausblenden von Daten (kann mithilfe von Strukturen / undurchsichtigen Zeigern erreicht werden)

2. Vererbung und Unterstützung des Polymorphismus (Einzelvererbung kann mithilfe von Strukturen erreicht werden - stellen Sie sicher, dass die abstrakte Basis nicht instanziierbar ist)

3. Konstruktor- und Destruktorfunktionalität (nicht leicht zu erreichen)

4. Typprüfung (zumindest für benutzerdefinierte Typen, da C keine erzwingt)

5. Referenzzählung (oder etwas, um RAII zu implementieren )

6. Eingeschränkte Unterstützung für die Ausnahmebehandlung (setjmp und longjmp)

Darüber hinaus sollte es sich auf ANSI / ISO-Spezifikationen und nicht auf compilerspezifische Funktionen stützen.

Schauen Sie sich http://ldeniau.web.cern.ch/ldeniau/html/oopc/oopc.html an . Wenn nichts anderes die Dokumentation durchliest, ist dies eine aufschlussreiche Erfahrung.

Ich bin ein bisschen zu spät zur Party hier, aber ich vermeide gerne beide Makro-Extreme - zu viele oder zu viele verschleierte Codes, aber ein paar offensichtliche Makros können die Entwicklung und das Lesen des OOP-Codes erleichtern:

/*
 * OOP in C
 *
 * gcc -o oop oop.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

struct obj2d {
    float x;                            // object center x
    float y;                            // object center y
    float (* area)(void *);
};

#define X(obj)          (obj)->b1.x
#define Y(obj)          (obj)->b1.y
#define AREA(obj)       (obj)->b1.area(obj)

void *
_new_obj2d(int size, void * areafn)
{
    struct obj2d * x = calloc(1, size);
    x->area = areafn;
    // obj2d constructor code ...
    return x;
}

// --------------------------------------------------------

struct rectangle {
    struct obj2d b1;        // base class
    float width;
    float height;
    float rotation;
};

#define WIDTH(obj)      (obj)->width
#define HEIGHT(obj)     (obj)->height

float rectangle_area(struct rectangle * self)
{
    return self->width * self->height;
}

#define NEW_rectangle()  _new_obj2d(sizeof(struct rectangle), rectangle_area)

// --------------------------------------------------------

struct triangle {
    struct obj2d b1;
    // deliberately unfinished to test error messages
};

#define NEW_triangle()  _new_obj2d(sizeof(struct triangle), triangle_area)

// --------------------------------------------------------

struct circle {
    struct obj2d b1;
    float radius;
};

#define RADIUS(obj)     (obj)->radius

float circle_area(struct circle * self)
{
    return M_PI * self->radius * self->radius;
}

#define NEW_circle()     _new_obj2d(sizeof(struct circle), circle_area)

// --------------------------------------------------------

#define NEW(objname)            (struct objname *) NEW_##objname()


int
main(int ac, char * av[])
{
    struct rectangle * obj1 = NEW(rectangle);
    struct circle    * obj2 = NEW(circle);

    X(obj1) = 1;
    Y(obj1) = 1;

    // your decision as to which of these is clearer, but note above that
    // macros also hide the fact that a member is in the base class

    WIDTH(obj1)  = 2;
    obj1->height = 3;

    printf("obj1 position (%f,%f) area %f\n", X(obj1), Y(obj1), AREA(obj1));

    X(obj2) = 10;
    Y(obj2) = 10;
    RADIUS(obj2) = 1.5;
    printf("obj2 position (%f,%f) area %f\n", X(obj2), Y(obj2), AREA(obj2));

    // WIDTH(obj2)  = 2;                                // error: struct circle has no member named width
    // struct triangle  * obj3 = NEW(triangle);         // error: triangle_area undefined
}

Ich denke, dies hat eine gute Balance, und die Fehler, die es (zumindest mit den Standardoptionen von gcc 6.3) für einige der wahrscheinlicheren Fehler erzeugt, sind hilfreich, anstatt zu verwirren. Der springende Punkt ist, die Produktivität der Programmierer zu verbessern, nicht wahr?

Wenn Sie einen kleinen Code schreiben müssen, versuchen Sie Folgendes: https://github.com/fulminati/class-framework

#include "class-framework.h"

CLASS (People) {
    int age;
};

int main()
{
    People *p = NEW (People);

    p->age = 10;

    printf("%d\n", p->age);
}

Ich arbeite auch daran basierend auf einer Makrolösung. Es ist also nur für die Mutigsten, denke ich ;-) Aber es ist schon ganz nett und ich arbeite bereits an ein paar Projekten darüber. Es funktioniert so, dass Sie zuerst eine separate Header-Datei für jede Klasse definieren. So was:

#define CLASS Point
#define BUILD_JSON

#define Point__define                            \
    METHOD(Point,public,int,move_up,(int steps)) \
    METHOD(Point,public,void,draw)               \
                                                 \
    VAR(read,int,x,JSON(json_int))               \
    VAR(read,int,y,JSON(json_int))               \

Um die Klasse zu implementieren, erstellen Sie eine Header-Datei und eine C-Datei, in der Sie die folgenden Methoden implementieren:

METHOD(Point,public,void,draw)
{
    printf("point at %d,%d\n", self->x, self->y);
}

In den Header, den Sie für die Klasse erstellt haben, fügen Sie andere benötigte Header hinzu und definieren Typen usw., die sich auf die Klasse beziehen. Sowohl im Klassenkopf als auch in der C-Datei enthalten Sie die Klassenspezifikationsdatei (siehe erstes Codebeispiel) und ein X-Makro. Diese X-Makros ( 1 , 2 , 3 usw.) erweitern den Code auf die tatsächlichen Klassenstrukturen und andere Deklarationen.

Um eine Klasse zu erben, #define SUPER supername und hinzufügensupername__define \ als erste Zeile in die Klassendefinition ein. Beide müssen da sein. Es gibt auch JSON-Unterstützung, Signale, abstrakte Klassen usw.

Um ein Objekt zu erstellen, verwenden Sie einfach W_NEW(classname, .x=1, .y=2,...) . Die Initialisierung basiert auf der in C11 eingeführten Strukturinitialisierung. Es funktioniert gut und alles, was nicht aufgeführt ist, wird auf Null gesetzt.

Verwenden Sie zum Aufrufen einer Methode W_CALL(o,method)(1,2,3) . Es sieht aus wie ein Funktionsaufruf höherer Ordnung, ist aber nur ein Makro. Es erweitert sich, ((o)->klass->method(o,1,2,3))was ein wirklich schöner Hack ist.

Siehe Dokumentation und den Code selbst .

Da das Framework Boilerplate-Code benötigt, habe ich ein Perl-Skript (Wobject) geschrieben, das den Job erledigt. Wenn Sie das verwenden, können Sie einfach schreiben

class Point
    public int move_up(int steps)
    public void draw()
    read int x
    read int y

und es werden die Klassenspezifikationsdatei, der Klassenkopf und eine C-Datei erstellt, die enthält, Point_impl.cwo Sie die Klasse implementieren. Es spart ziemlich viel Arbeit, wenn Sie viele einfache Klassen haben, aber immer noch alles in C. Wobject ist ist ein sehr einfacher Scanner auf der Basis regulärer Ausdrücke, der sich leicht an bestimmte Anforderungen anpassen oder von Grund auf neu schreiben lässt.

Das Open-Source-Dynace-Projekt macht genau das. Es ist unter https://github.com/blakemcbride/Dynace

Sie können COOP ausprobieren , ein programmiererfreundliches Framework für OOP in C, das Klassen, Ausnahmen, Polymorphismus und Speicherverwaltung (wichtig für eingebetteten Code) enthält. Es ist eine relativ leichte Syntax, siehe das Tutorial im Wiki .