OOP and interfaces in C

There are three distinct ways you can achieve polymorphism in C:

1. Code it out
   In the base class functions, just switch on a class type ID to call the specialized versions. An incomplete code example:

   typedef enum classType {    CLASS_A,    CLASS_B} classType;typedef struct base {    classType type;} base;typedef struct A {    base super;    ...} A;typedef struct B {    base super;    ...} B;void A_construct(A* me) {    base_construct(&me->super);    super->type = CLASS_A;}int base_foo(base* me) {    switch(me->type) {        case CLASS_A: return A_foo(me);        case CLASS_B: return B_foo(me);        default: assert(0), abort();    }}

   Of course, this is tedious to do for large classes.

2. Store function pointers in the object
   You can avoid the switch statements by using a function pointer for each member function. Again, this is incomplete code:

   typedef struct base {    int (*foo)(base* me);} base;//class definitions for A and B as aboveint A_foo(base* me);void A_construct(A* me) {    base_construct(&me->super);    me->super.foo = A_foo;}

   Now, calling code may just do

   base* anObject = ...;(*anObject->foo)(anObject);

   Alternatively, you may use a preprocessor macro along the lines of:

   #define base_foo(me) (*me->foo)(me)

   Note that this evaluates the expression me twice, so this is really a bad idea. This may be fixed, but that's beyond the scope of this answer.

3. Use a vtable
   Since all objects of a class share the same set of member functions, they can all use the same function pointers. This is very close to what C++ does under the hood:

   typedef struct base_vtable {    int (*foo)(base* me);    ...} base_vtable;typedef struct base {    base_vtable* vtable;    ...} base;typedef struct A_vtable {    base_vtable super;    ...} A_vtable;//within A.cint A_foo(base* super);static A_vtable gVtable = {    .foo = A_foo,    ...};void A_construct(A* me) {    base_construct(&me->super);    me->super.vtable = &gVtable;};

   Again, this allows the user code to do the dispatch (with one additional indirection):

   base* anObject = ...;(*anObject->vtable->foo)(anObject);

Which method you should use depends on the task at hand. The switch based approach is easy to whip up for two or three small classes, but is unwieldy for large classes and hierarchies. The second approach scales much better, but has a lot of space overhead due to the duplicated function pointers. The vtable approach requires quite a bit of additional structure and introduces even more indirection (which makes the code harder to read), but is certainly the way to go for complex class hierarchies.

Can you compromise with the following:

#include <stdio.h>struct effect_ops {    float (*processEffect)(void *effect);    /* + other operations.. */};struct DelayClass {    unsigned delay;    struct effect_ops *ops;};struct FlangerClass {    unsigned period;    struct effect_ops *ops;};/* The actual effect functions are here * Pointers to the actual structure may be needed for effect-specific parameterization, etc. */float flangerEffect(void *flanger){   struct FlangerClass *this = flanger;   /* mix signal delayed by this->period with original */   return 0.0f;}float delayEffect(void *delay){    struct DelayClass *this = delay;    /* delay signal by this->delay */    return 0.0f;}/* Instantiate and assign a "default" operation, if you want to */static struct effect_ops flanger_operations = {    .processEffect = flangerEffect,};static struct effect_ops delay_operations = {    .processEffect = delayEffect,};int main(){    struct DelayClass delay     = {.delay = 10, .ops = &delay_operations};    struct FlangerClass flanger = {.period = 1, .ops = &flanger_operations};    /* ...then for your signal */    flanger.ops->processEffect(&flanger);    delay.ops->processEffect(&delay);    return 0;}

You implement interfaces using structs of function pointers. You can then have the interface struct embedded in your data object struct and pass the interface pointer as first parameter of every interface member function. In that function you then get the pointer to your container class (which is specific to your implementation) using container_of () macro. Search for "container_of linux kernel" for an implementation. It is a very useful macro.