Orientasi objek dalam C

Apa yang akan menjadi set hacks preprocessor yang bagus (kompatibel ANSI C89 / ISO C90) yang memungkinkan semacam orientasi objek yang jelek (tetapi dapat digunakan) di C?

Saya akrab dengan beberapa bahasa berorientasi objek yang berbeda, jadi jangan merespons dengan jawaban seperti "Pelajari C ++!". Saya telah membaca " Pemrograman Berorientasi Objek Dengan ANSI C " (berhati-hatilah: format PDF ) dan beberapa solusi menarik lainnya, tetapi saya lebih tertarik dengan Anda :-)!

Lihat juga Bisakah Anda menulis kode berorientasi objek dalam C?

C Object System (COS) terdengar menjanjikan (masih dalam versi alpha). Ini mencoba untuk meminimalkan konsep yang tersedia demi kesederhanaan dan fleksibilitas: pemrograman berorientasi objek yang seragam termasuk kelas terbuka, metaclasses, metaclasses properti, generik, multimethod, delegasi, kepemilikan, pengecualian, kontrak dan penutupan. Ada draft paper (PDF) yang menjelaskannya.

Pengecualian dalam C adalah implementasi C89 dari TRY-CATCH-FINALLY yang ditemukan dalam bahasa OO lainnya. Itu datang dengan testuite dan beberapa contoh.

Baik oleh Laurent Deniau, yang bekerja banyak pada OOP di C .

Saya akan menyarankan terhadap preprocessor (ab) gunakan untuk mencoba dan membuat sintaks C lebih seperti itu dari bahasa yang lebih berorientasi objek. Pada level paling dasar, Anda hanya menggunakan struct sederhana sebagai objek dan membagikannya dengan pointer:

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

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

Untuk mendapatkan hal-hal seperti warisan dan polimorfisme, Anda harus bekerja lebih keras. Anda dapat melakukan pewarisan manual dengan membuat anggota pertama struktur menjadi instance dari superclass, dan kemudian Anda dapat melemparkan pointer ke kelas basis dan turunan secara bebas:

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

Untuk mendapatkan polimorfisme (yaitu fungsi virtual), Anda menggunakan pointer fungsi, dan tabel penunjuk fungsi opsional, juga dikenal sebagai tabel virtual atau tabel:

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

Dan itulah bagaimana Anda melakukan polimorfisme dalam C. Ini tidak cantik, tetapi itu berhasil. Ada beberapa masalah lengket yang melibatkan lemparan pointer antara kelas basis dan turunan, yang aman selama kelas basis adalah anggota pertama dari kelas turunan. Multiple inheritance jauh lebih sulit - dalam hal ini, untuk membedakan antara kelas dasar selain yang pertama, Anda perlu menyesuaikan pointer secara manual berdasarkan offset yang tepat, yang benar-benar rumit dan rawan kesalahan.

Hal lain (rumit) yang dapat Anda lakukan adalah mengubah tipe dinamis suatu objek saat runtime! Anda baru saja menetapkan ulang pointer vtable baru. Anda bahkan dapat secara selektif mengubah beberapa fungsi virtual sambil menjaga yang lain, menciptakan tipe hybrid baru. Berhati-hatilah untuk membuat vtable baru alih-alih memodifikasi global vtable, jika tidak, Anda akan secara tidak sengaja memengaruhi semua objek dari jenis tertentu.

Saya pernah bekerja dengan perpustakaan C yang diimplementasikan dengan cara yang menurut saya cukup elegan. Mereka telah menulis, dalam C, cara untuk mendefinisikan objek, kemudian mewarisi dari mereka sehingga mereka dapat diperluas sebagai objek C ++. Ide dasarnya adalah ini:

• Setiap objek memiliki file sendiri
• Fungsi dan variabel publik didefinisikan dalam file .h untuk suatu objek
• Variabel dan fungsi pribadi hanya terletak di file .c
• Untuk "mewarisi" sebuah struct baru dibuat dengan anggota pertama dari struct yang menjadi objek untuk diwarisi

Warisan sulit untuk dijelaskan, tetapi pada dasarnya begini:

struct vehicle {
   int power;
   int weight;
}

Kemudian di file lain:

struct van {
   struct vehicle base;
   int cubic_size;
}

Maka Anda bisa membuat van dibuat dalam memori, dan digunakan oleh kode yang hanya tahu tentang kendaraan:

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

Ini bekerja dengan indah, dan file .h mendefinisikan dengan tepat apa yang harus Anda lakukan dengan setiap objek.

Desktop GNOME untuk Linux ditulis dalam berorientasi objek C, dan memiliki model objek yang disebut " GObject " yang mendukung properti, warisan, polimorfisme, serta beberapa barang lain seperti referensi, penanganan acara (disebut "sinyal"), runtime mengetik, data pribadi, dll.

Ini termasuk preprocessor hacks untuk melakukan hal-hal seperti mengetik di hierarki kelas, dll. Berikut adalah contoh kelas yang saya tulis untuk GNOME (hal-hal seperti gchar adalah typedefs):

Sumber Kelas

Header kelas

Di dalam struktur GObject ada bilangan bulat GType yang digunakan sebagai angka ajaib untuk sistem pengetikan dinamis GLib (Anda dapat melemparkan seluruh struct ke "GType" untuk menemukan jenisnya).

Saya dulu melakukan hal semacam ini di C, sebelum saya tahu apa itu OOP.

Berikut ini adalah contoh, yang mengimplementasikan buffer data yang tumbuh sesuai permintaan, mengingat ukuran minimum, peningkatan dan ukuran maksimum. Implementasi khusus ini adalah "elemen" berbasis, yang mengatakan itu dirancang untuk memungkinkan koleksi seperti daftar dari semua jenis C, bukan hanya byte-buffer panjang variabel.

Idenya adalah bahwa objek instantiated menggunakan xxx_crt () dan dihapus menggunakan xxx_dlt (). Setiap metode "anggota" membutuhkan pointer yang diketik khusus untuk beroperasi.

Saya menerapkan daftar tertaut, buffer siklik, dan sejumlah hal lain dengan cara ini.

Saya harus akui, saya tidak pernah memikirkan bagaimana menerapkan warisan dengan pendekatan ini. Saya membayangkan bahwa beberapa perpaduan yang ditawarkan oleh Kieveli mungkin merupakan jalan yang baik.

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 hanyalah tip int - saya menggunakannya untuk mengingatkan saya bahwa panjangnya adalah variabel dari platform ke platform (untuk porting).

Sedikit di luar topik, tetapi kompiler C ++ asli, Cfront , mengkompilasi C ++ ke C dan kemudian ke assembler.

Diawetkan di sini .

Jika Anda berpikir tentang metode yang memanggil objek sebagai metode statis yang melewatkan implisit thiske fungsi itu dapat membuat berpikir OO dalam C lebih mudah.

Sebagai contoh:

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

menjadi:

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

Atau semacam itu.

ffmpeg (toolkit untuk pemrosesan video) ditulis dalam C lurus (dan bahasa rakitan), tetapi menggunakan gaya berorientasi objek. Ini penuh dengan struct dengan pointer fungsi. Ada satu set fungsi pabrik yang menginisialisasi struct dengan petunjuk "metode" yang sesuai.

Jika Anda benar-benar berpikir secara hati-hati, bahkan standar penggunaan C perpustakaan OOP - menganggap FILE *sebagai contoh: fopen()menginisialisasi sebuah FILE *objek, dan Anda menggunakannya menggunakan metode anggota fscanf(), fprintf(), fread(), fwrite()dan lain-lain, dan akhirnya menyelesaikan dengan fclose().

Anda juga bisa menggunakan cara pseudo-Objective-C yang tidak sulit juga:

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

Menggunakan:

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

Inilah yang mungkin dihasilkan dari beberapa kode Objective-C seperti ini, jika penerjemah Objective-C-to-C yang cukup lama digunakan:

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

Saya pikir apa yang diposting Adam Rosenfield adalah cara yang benar untuk melakukan OOP di C. Saya ingin menambahkan bahwa apa yang dia tunjukkan adalah implementasi objek. Dengan kata lain implementasi yang sebenarnya akan dimasukkan ke dalam .cfile, sedangkan antarmuka akan dimasukkan ke dalam .hfile header . Misalnya, menggunakan contoh monyet di atas:

Antarmuka akan terlihat seperti:

//monkey.h

    struct _monkey;

    typedef struct _monkey monkey;

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

Anda dapat melihat di .hfile antarmuka Anda hanya mendefinisikan prototipe. Anda kemudian dapat mengkompilasi bagian " .cfile" implementasi ke perpustakaan statis atau dinamis. Ini menciptakan enkapsulasi dan Anda juga dapat mengubah implementasinya sesuka hati. Pengguna objek Anda perlu tahu hampir tidak ada tentang penerapannya. Ini juga menempatkan fokus pada desain keseluruhan objek.

Ini keyakinan pribadi saya bahwa oop adalah cara untuk mengkonseptualisasikan struktur kode Anda dan penggunaan kembali dan benar-benar tidak ada hubungannya dengan hal-hal lain yang ditambahkan ke c ++ seperti overloading atau template. Ya itu adalah fitur berguna yang sangat bagus tetapi mereka tidak mewakili pemrograman berorientasi objek apa sebenarnya.

Rekomendasi saya: tetap sederhana. Salah satu masalah terbesar yang saya miliki adalah memelihara perangkat lunak yang lebih lama (terkadang lebih dari 10 tahun). Jika kodenya tidak sederhana, itu bisa sulit. Ya, orang dapat menulis OOP yang sangat berguna dengan polimorfisme dalam C, tetapi bisa sulit dibaca.

Saya lebih suka objek sederhana yang merangkum beberapa fungsi yang terdefinisi dengan baik. Contoh yang bagus untuk hal ini adalah GLIB2 , misalnya tabel hash:

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

Kuncinya adalah:

1. Arsitektur sederhana dan pola desain
2. Mencapai enkapsulasi OOP dasar.
3. Mudah diimplementasikan, dibaca, dimengerti, dan dipelihara

Jika saya akan menulis OOP di CI mungkin akan pergi dengan desain pseudo- Pimpl . Alih-alih meneruskan pointer ke struct, Anda akhirnya melewati pointer ke pointer ke struct. Ini membuat konten menjadi buram dan memfasilitasi polimorfisme dan pewarisan.

Masalah sebenarnya dengan OOP di C adalah apa yang terjadi ketika variabel keluar dari ruang lingkup. Tidak ada destruktor yang dihasilkan kompiler dan yang dapat menyebabkan masalah. Makro mungkin bisa membantu, tetapi akan selalu jelek untuk dilihat.

Cara lain untuk memprogram dalam gaya berorientasi objek dengan C adalah dengan menggunakan generator kode yang mengubah bahasa domain spesifik menjadi C. Seperti yang dilakukan dengan TypeScript dan JavaScript untuk membawa OOP ke js.

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

Keluaran:

6.56
13.12

Berikut ini adalah pertunjukan tentang apa itu pemrograman OO dengan C.

Ini nyata, C murni, tidak ada makro preprosesor. Kami memiliki pewarisan, polimorfisme, dan enkapsulasi data (termasuk data pribadi ke kelas atau objek). Tidak ada peluang untuk setara kualifikasi yang dilindungi, yaitu, data pribadi juga bersifat pribadi di rantai pewarisan juga. Tapi ini bukan ketidaknyamanan karena saya pikir itu tidak perlu.

CPolygon tidak dipakai karena kami hanya menggunakannya untuk memanipulasi objek dari rantai bawaan yang memiliki aspek umum tetapi implementasi yang berbeda dari mereka (Polimorfisme).

@Adam Rosenfield memiliki penjelasan yang sangat bagus tentang bagaimana mencapai OOP dengan C

Selain itu, saya akan merekomendasikan Anda untuk membaca

1) pjsip

Pustaka C yang sangat bagus untuk VoIP. Anda dapat mempelajari cara mencapai OOP melalui struct dan tabel pointer fungsi

2) iOS Runtime

Pelajari bagaimana iOS Runtime menggerakkan Objective C. Ini mencapai OOP melalui isa pointer, kelas meta

Bagi saya orientasi objek dalam C harus memiliki fitur-fitur ini:

1. Enkapsulasi dan penyembunyian data (dapat dicapai dengan menggunakan struct / pointer buram)

2. Warisan dan dukungan untuk polimorfisme (pewarisan tunggal dapat dicapai dengan menggunakan struct - pastikan basis abstrak tidak instantiable)

3. Fungsi konstruktor dan destruktor (tidak mudah dicapai)

4. Pengecekan tipe (setidaknya untuk tipe yang ditentukan pengguna karena C tidak menerapkan apa pun)

5. Penghitungan referensi (atau sesuatu untuk mengimplementasikan RAII )

6. Dukungan terbatas untuk penanganan pengecualian (setjmp dan longjmp)

Di atas semua itu harus bergantung pada spesifikasi ANSI / ISO dan tidak boleh bergantung pada fungsi spesifik kompiler.

Lihatlah http://ldeniau.web.cern.ch/ldeniau/html/oopc/oopc.html . Jika tidak ada yang lain membaca dokumentasi adalah pengalaman yang mencerahkan.

Saya agak terlambat ke pesta di sini, tetapi saya ingin menghindari kedua makro ekstrem - terlalu banyak atau terlalu banyak kode mengaburkan, tetapi beberapa makro yang jelas dapat membuat kode OOP lebih mudah untuk dikembangkan dan dibaca:

/*
 * 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
}

Saya pikir ini memiliki keseimbangan yang baik, dan kesalahan yang dihasilkannya (setidaknya dengan opsi default gcc 6.3) untuk beberapa kesalahan yang lebih mungkin membantu daripada membingungkan. Intinya adalah untuk meningkatkan produktivitas programmer, bukan?

Jika Anda perlu menulis sedikit kode coba ini: 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);
}

Saya juga sedang mengerjakan ini berdasarkan pada solusi makro. Jadi itu hanya untuk yang paling berani, saya kira ;-) Tapi itu sudah cukup bagus, dan saya sudah mengerjakan beberapa proyek di atasnya. Ini berfungsi agar Anda pertama kali menentukan file header terpisah untuk setiap kelas. Seperti ini:

#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))               \

Untuk mengimplementasikan kelas, Anda membuat file header untuk itu dan file C tempat Anda menerapkan metode:

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

Di header yang Anda buat untuk kelas, Anda menyertakan header lain yang Anda butuhkan dan menentukan jenis dll yang terkait dengan kelas. Baik di header kelas dan di file C Anda menyertakan file spesifikasi kelas (lihat contoh kode pertama) dan X-makro. Makro X ini ( 1 , 2 , 3 dll.) Akan memperluas kode ke struct kelas aktual dan deklarasi lainnya.

Untuk mewarisi kelas, #define SUPER supernamedan tambahkan supername__define \sebagai baris pertama dalam definisi kelas. Keduanya pasti ada di sana. Ada juga dukungan JSON, sinyal, kelas abstrak, dll.

Untuk membuat objek, cukup gunakan W_NEW(classname, .x=1, .y=2,...) . Inisialisasi didasarkan pada inisialisasi struct yang diperkenalkan pada C11. Ini bekerja dengan baik dan semua yang tidak terdaftar diatur ke nol.

Untuk memanggil metode, gunakan W_CALL(o,method)(1,2,3) . Sepertinya panggilan fungsi tingkat tinggi tetapi ini hanya makro. Perluasan ((o)->klass->method(o,1,2,3))yang merupakan hack yang sangat bagus.

Lihat Dokumentasi dan kode itu sendiri .

Karena kerangka kerja membutuhkan beberapa kode boilerplate, saya menulis skrip Perl (wobject) yang berfungsi. Jika Anda menggunakannya, Anda bisa menulis

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

dan itu akan membuat file spesifikasi kelas, header kelas, dan file C, yang termasuk di Point_impl.cmana Anda mengimplementasikan kelas. Menghemat banyak pekerjaan, jika Anda memiliki banyak kelas sederhana tetapi masih semuanya dalam C. wobject adalah pemindai berbasis ekspresi reguler yang sangat sederhana yang mudah untuk beradaptasi dengan kebutuhan spesifik, atau ditulis ulang dari awal.

Proyek Dynace open-source melakukan hal itu. Itu di https://github.com/blakemcbride/Dynace

Anda dapat mencoba COOP , kerangka kerja yang ramah programmer untuk OOP di C, fitur Kelas, Pengecualian, Polimorfisme, dan Manajemen Memori (penting untuk kode Embedded). Ini sintaks yang relatif ringan, lihat tutorial di Wiki di sana.