How can I simulate OO-style polymorphism in C?

Question

Is there a way to write OO-like code in the C programming language?

---

See also:

• Can you write object-oriented code in C?
• Object-orientation in C

Found by searching on "[c] oo".

Engrave

_Generic can be used for compile time polymorphism. __attribute__((cleanup (<cleanup function>))) can be used for RAII. And error codes are superior to exception handling. – Subside

Answer 1

The first C++ compiler ("C with classes") would actually generate C code, so that's definitely doable.

Basically, your base class is a struct; derived structs must include the base struct at the first position, so that a pointer to the "derived" struct will also be a valid pointer to the base struct.

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

The functions can be part of the structure as function pointers, so that a syntax like p->call(p) becomes possible, but you still have to explicitly pass a pointer to the struct to the function itself.

Brigantine

This doesn't explain how method overriding would work in C. How can you override function_on_base to access derived's memeber_y as you can in C++ polymorphic calls? – Heteromerous

Overriding is not possible in C. – Roca

This answer is incorrect. Passing a struct derived* to function_on_base will not compile; struct derived* is a different type than struct base* even if the address is correct; however, if you cast the pointer from derived* to base*, it will work (but you'll miss out on compile-time type checking and instead get a crash at runtime). @PatrickCollins Overriding is possible in C: pastebin.com/W5xEytbv – Nipple

@JohnK See above comment. – Nipple

@Nipple Right you are, I'm not really sure what I was thinking when I wrote that. I might have had "overloading" in mind, which your paste also suggests. – Roca

@PatrickCollins I actually never remember which phrase is correct, and I use them interchangeably when referring to the mechanism illustrated in my paste. :) – Nipple

Sadly this involves casting pointers and then dereferencing them, which is a strict aliasing violation and invokes UB – Ryals

couldn't you use a union for all your descendant types, each having the base struct as the first member in packing order? – Petro

@SamuelPeter: If you're referring to the cast from derived* to base*, I think you might be mistaken. It's fair game to cast between pointers to two types if one is the first non-bitfield member of the other. See https://mcmap.net/q/48242/-struct-extension-in-c. – Schoolboy

Answer 2

Common approach is to define struct with pointers to functions. This defines 'methods' which can be called on any type. Subtypes then set their own functions in this common structure, and return it.

For example, in linux kernel, there is struct:

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

Each registered type of filesystem then registers its own functions for create, lookup, and remaining functions. Rest of code can than use generic inode_operations:

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

Rosaleerosaleen

That's basically how cfront (the original C++ compiler) converted C++ to C that was then compiled with pcc. I learned a lot about how this worked dealing with core files from that mess. – Babylonian

This isn't C++ style polymorphism. A big advantage of polymorphism over function pointers is that polymorphism allows for data binding, while function pointers does not. In this case, there is no opportunity for data binding, it's just a struct of function pointers. Also, I think the struct is superfluous in this comment. – Reputation

Answer 3

C++ is not that far from C.

Classes are structures with a hidden pointer to a table of function pointers called VTable. The Vtable itself is static. When types point to Vtables with the same structure but where pointers point to other implementation, you get polymorphism.

It is recommended to encapsulate the calls logic in function that take the struct as parameter to avoid code clutter.

You should also encapsulcte structures instantiation and initialisation in functions (this is equivalent to a C++ constructor) and deletion (destructor in C++). These are good practice anyway.

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

typedef struct
{
   VTable* pVTable;
   int member;

} TheClass;

To call the method:

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

Namaqualand

The example is incomplete. There is no explanation for how to implement a new class with different members (besides just the int). In this case, it seems that all of the "polymorphic" objects will have the same int member. What if you want to define classes with different members? I think in that case your struct should have a void pointer to data members, instead of a concrete int. – Reputation

@Reputation the example implements a vtable which calls functions at runtime, exactly what c++ would do behind the scenes if you create a class. – Dunnite

@NiclasLarsson In C++ it is possible to create another class inheriting the pure virtual functions, but with different member variables. Then, the virtual function implemented in that class can use those member variables. This is a key aspect of polymorphism. The example does not demonstrate how to do this. For this example, you might as well just use function pointer. – Reputation

@Reputation Check out my answer. The only thing that you need is that both structs have the common fields in the same places. If a common field is on the 3rd spot in parent class, it must be on the 3rd spot in the child class. You do this with all the fields that 2 classes share and you put the common fields in the beginning of the child struct. The same way vTable pointer should be on the same spot in both classes. That's how you can hack polymorphism into C. – Homophony

Answer 4

I looked at everyone elses' answers and came up with this:

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

I hope that answers some questions.

Inner

Good example. Would be even better if you had 2 "derived" classes with different init / get / set. "private" members / functions can be done with opaque structs. Naming convention is also important: mylib_someClass_aMethod(this) is a good possibility. – Staffman

This looks neat. I put this into a c file and compiled alright for an ARM micro controller. I am not getting far yet but just like to drop a note as an acknowledgement to red_hax0r's post. – Arrester

where is polymorphism? – Farrago

Answer 5

Appendix B of the article Open Reusable Object Models, by Ian Piumarta and Alessandro Warth of VPRI is an implementation of an Object model in GNU C, about 140 lines of code. It's a fascinating read !

Here's the uncached version of the macro that sends messages to objects, using a GNU extension to C (statement expression):

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

In the same doc, have a look at the object, vtable, vtable_delegated and symbol structs, and the _bind and vtable_lookup functions.

Cheers!

Scapolite

Answer 6

What I usually like to do is to wrap the structs in another which contain meta information about the wrapped class and then build visitor like function lists acting on the generic struct. The advantage of this approach is that you don't need to modify the existing structures and you can create visitors for any subset of structs.

Take the usual example:

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

We can wrap the 2 strutures in this new structure:

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

The type can be a simple int but let's not be lazy:

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

It would be nice to have some wrapping functions:

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

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

Now we can define our "visitor":

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

Then the actual usage will be:

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

The disadvantage of this approach is that you have to wrap the structures every time you want to use it as a generic type.

Beaujolais

My solution scales automatically but it doesn't allow multiple inheritance nor implementing multiple interfaces. Your approach allows simulating multiple interface implementation like you can do in Java. However, this approach requires a lot of discipline, there is no automation, you need to manually add and remove function pointers from animalCalls and to add and remove from AnimalType. You also must make sure that the order both at AnimalTypes as well as the order at animalCalls is correct (I imagine it would be easy to make mistakes of this type when changing code). – Homophony

Answer 7

The file functions fopen, fclose, fread are examples of OO code in C. Instead of the private data in class, they work on the FILE structure which is used to encapsulate the data and the C functions acts as an member class functions. http://www.amazon.com/File-Structures-Object-Oriented-Approach-C/dp/0201874016

Quickie

The book pointed to is C++ only. Note: I have a copy and would not recommend it today. If I had one OO recommendation in C to give today it would be C Interfaces and Implementations: Techniques for Creating Reusable Software by David Hanson (amzn.com/0201498413). Absolutely brilliant book and most programmers would do well to understand it, most examples in it are taken from compiler backends so the code is exemplary. – Hutton

Answer 8

#include <stdio.h>

typedef struct {
    int  x;
    int z;
} base;

typedef struct {
    base;
    int y;
    int x;
} derived;

void function_on_base( base * a) // here I can pass both pointers to derived and to base
{
    printf("Class base [%d]\n",a->x);
    printf("Class base [%d]\n",a->z);
}
void function_on_derived( derived * b) // here I must pass a pointer to the derived class
{
    printf("Class derived [%d]\n",b->y);
    printf("Class derived [%d]\n",b->x);
}

int main()
{
    derived d;
    base b;
    printf("Teste de poliformismo\n");

    b.x = 2;
    d.y = 1;
    b.z = 3;
    d.x = 4;
    function_on_base(&b);
    function_on_base(&d);
    function_on_derived(&b);
    function_on_derived(&d);
    return 0;
}

The output was:

Class base [3]
Class base [1]
Class base [4]
Class derived [2]
Class derived [3]
Class derived [1]
Class derived [4]

so it works, its a polymorphic code.

UncleZeiv explained about it at the beginning.

Haim

Answer 9

From Wikipedia: In programming languages and type theory, polymorphism (from Greek πολύς, polys, "many, much" and μορφή, morphē, "form, shape") is the provision of a single interface to entities of different types.

So I would say the only way to implement it in C is by using variadic arguments along with some (semi)automatic type info management. For example in C++ you can write (sorry for trivialness):

void add( int& result, int a1, int a2 );
void add( float& result, float a1, float a2 );
void add( double& result, double a1, double a2 );

In C, among other solutions, the best you can do is something like this:

int int_add( int a1, int a2 );
float float_add( float a1, fload a2 );
double double_add( double a1, double a2 );

void add( int typeinfo, void* result, ... );

Then you need:

1. to implement the "typeinfo" with enums/macros
2. to implement the latter function with stdarg.h stuff
3. to say goodbye to C static type checking

I am almost sure that any other implementation of polymorphism should look much like this very one. The above answers, instead, seems to try to address inheritance more than polymorphism!

Melina

In C11, the new _Generic keyword simplifies this design pattern a great deal. I highly recommend it for those choosing this approach. – Udo

Answer 10

In order too build OO functionality in C, you can look at previous answers.

But, (as it has been asked in other questions redirected to this one) if you want to understand what polymorphism is, by examples in C language. Maybe I am wrong, but I can't think of anything as easy to understand as C pointers arithmetic. In my opinion, pointer arithmetic is inherently polymorphic in C. In the following example the same function (method in OO), namely the addition (+), will produce a different behavior depending on the properties of the input structures.

Example:

double a*;
char str*;

a=(double*)malloc(2*sizeof(double));
str=(char*)malloc(2*sizeof(char)); 

a=a+2; // make the pointer a, point 2*8 bytes ahead.

str=str+2; // make the pointer str, point 2*1 bytes ahead.

Disclaimer: I am very new at C and very much looking forward to being corrected and learn from other user's comments, or even completely erase this answer, should it be wrong. Many thanks,

Tetrachloride

Answer 11

A very crude example of simple function overloading, much can be achieved using variadic macros.

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

#define SCOPE_EXIT(X) __attribute__((cleanup (X)))

struct A
{
  int a;
};

struct B
{
 int a, b;
};

typedef struct A * A_id;
typedef struct B * B_id;


A_id make_A()
{
   return (A_id)malloc(sizeof(struct A));
}

void destroy_A(A_id * ptr)
{
   free(*ptr);
   *ptr = 0;
}

B_id make_B()
{
  return (B_id)malloc(sizeof(struct B));
}

void destroy_B(B_id * ptr)
{
  free(*ptr);
  *ptr = 0;
}

void print_a(A_id ptr)
{
  printf("print_a\n"); 
}
void print_b(B_id ptr)
{
  printf("print_b\n"); 
}

#define print(X) _Generic((X),\
          A_id : print_a, \
          B_id : print_b\
)(X)

int main()
{
  A_id aa SCOPE_EXIT(destroy_A) = make_A();
  print(aa);

  B_id bb SCOPE_EXIT(destroy_B) = make_B();
  print(bb);
  return 0;
}

Subside

Answer 12

Different implementations of functions is one of the key features of polymorphism, so you must use function pointers.

animal.h

typedef struct Animal {
    const void (*jump)(struct Animal *self);
} Animal;

pig.h

#include "animal.h"

typedef struct {
    Animal animal_interface;
    char *name;
} Pig;

Pig *NewPig(char *name);

pig.c

#include <stdio.h>
#include <stdlib.h>
#include "pig.h"

static void PigJump(Animal *_self) {
    Pig *self = (Pig *)_self;
    printf("%s Pig jump.\n", self->name);
}

Pig *NewPig(char *name) {
    Pig *self = (Pig *)malloc(sizeof(Pig));
    self->animal_interface.jump = PigJump;
    self->name = name;
    return self;
}

main.c

#include "pig.h"

int main() {
    Animal *a = &(NewPig("Peppa")->animal_interface);
    Animal *b = &(NewPig("Daddy")->animal_interface);
    a->jump(a);
    b->jump(b);
    return 0;
}

Output:

Peppa Pig jump.
Daddy Pig jump.

Wallow

Answer 13

I have successfully achieved polymorphism in C so I felt like sharing my code. I have a struct Pas which "inherits" from struct Zivotinja (Pas means Dog, Zivotinja means Animal BTW).

In both Zivotinja and Pas the first field of the struct is the vTable. Zivotinja has a vTable of the type ZivotinjaVTable, Pas has a vTable of the type PasVTable. So, we have

 typedef struct ZivotinjaVTableStruct{
    void (*ispisiPodatkeOZivotinji)(void *zivotinja);
    int (*dajGodine) (void *zivotinja);
} ZivotinjaVTable;

typedef struct ZivotinjaStruct{
        ZivotinjaVTable *vTable;
        int godine;
    } Zivotinja;

and we have

typedef struct PasVTableStruct{
    void (*ispisiPodatkeOZivotinji)(void *Pas);
    int (*dajGodine) (void *Pas);
    bool (*daLiJeVlasnikStariji) (void *Pas);
} PasVTable;

typedef struct PasStruct{
    PasVTable *vTable;
    int godine;
    const char* vlasnik;
    int godineVlasnika;
} Pas;

Don't worry about the names of the functions, that's not relevant. Anyway, I then wrote functions for both of these vTables. How did I connect the vTables with the functions that I wrote for them? I created a global struct both for the ZivotinjaVTable and for the PasVTable. I created vTableZivotinjaGlobal and vTablePasGlobal which have function pointers of the functions that I wrote. Then I created functions Pas_new() and Zivotinja_new() which initialize vTable fields to point to these global vTable structs. Notice the important details in the code above. The important thing is that vTables are the first fields in their structs. That way, when we write

Zivotinja *z = (Zivotinja*) Pas_new(/* init variables */);
z->vTable->someMethod(z);

the compiler knows that vTable is the first field in the Zivotinja struct, so when compiler reads z->vTable, it will go to the memory address to which the first 8 bytes of your struct z point to (or first 4 bytes, if you have a 32bit PC, but that is irrelevant for the point that I am making). This is how I tricked the computer, since this z pointer is actually pointing to a Pas struct and since PasVTable *vTable is the first field of the Pas struct, after z->vTable we will actually be at the memory address of the pasVTableGlobal, instead of being at the memory address of the zivotinjaVTableGlobal.

Now, another very important detail, someMethod needs to be at the same spot both in the ZivotinjaVTable and in the PasVTable. What I mean is - if someMethod is the 2nd field in the ZivotinjaVTable then it needs to be the second field of the PasVTable. Why? Because let's say someMethod is the second field of the ZivotinjaVTable, when the compiler reads z->vTable->someMethod(z); computer will take the second 8 bytes in the memory address z->vTable and it will put those 8 bytes into the instruction pointer (or second 4 bytes if you have a 32 bit PC, but again, this is not relevant). Computer "thinks" it is putting the second 8 bytes of the ZivotinjaVTable into the instruction pointer, but in reality it is putting the second 8 bytes of the PasVTable into the instruction pointer. This is how the trick works, because the function that we want the computer to execute is also the second field (but of the PasVTable, not ZivotinjaVTable), the computer will "think" that it is executing the second function of the ZivotinjaVTable, but in reality it will be executing the second function of the PasVTable.
So, to recapitulate, vTables should be on the same spot in your structs and your structs should have corresponding methods at the same spots in their vTables. Same goes for other fields of your structs. The second field of the Zivotinja struct matches the second field of the Pas struct, that way when you write

animal_which_is_actually_a_dog->age = 10;

You will trick the compiler in basically the same way as with vTables (you will trick it in the same way that I have described above). Here is the entire code, in the main function you can write the following

    Zivotinja *zivotinja = Zivotinja_new(10);
    zivotinja->vTable->ispisiPodatkeOZivotinji(zivotinja);

    Zivotinja *pas = Pas_new_sve(5, 50, "Milojko");
    pas->vTable->ispisiPodatkeOZivotinji(pas); 
    int godine = pas->vTable->dajGodine(pas); 
    printf("The dog which was casted to an animal is %d years old.\n", godine);

Then this is the code for Zivotinja

typedef struct ZivotinjaVTableStruct{
    void (*ispisiPodatkeOZivotinji)(void *zivotinja);
    int (*dajGodine) (void *zivotinja);
} ZivotinjaVTable;


typedef struct ZivotinjaStruct{
    ZivotinjaVTable *vTable;
    int godine;
} Zivotinja;


void ispisiPodatkeOOvojZivotinji(Zivotinja* zivotinja){
    printf("Ova zivotinja ima %d godina. \n", zivotinja->godine);
}

int dajGodineOveZivotinje(Zivotinja *z){
    return z->godine;
}

struct ZivotinjaVTableStruct zivotinjaVTableGlobal = {ispisiPodatkeOOvojZivotinji, dajGodineOveZivotinje};


Zivotinja* Zivotinja_new(int godine){
    ZivotinjaVTable *vTable = &zivotinjaVTableGlobal;

    Zivotinja *z = (Zivotinja*) malloc(sizeof(Zivotinja));
    z->vTable = vTable;
    z->godine = godine;
}

And finally, the code for Pas

typedef struct PasVTableStruct{
    void (*ispisiPodatkeOZivotinji)(void *Pas);
    int (*dajGodine) (void *Pas);
    bool (*daLiJeVlasnikStariji) (void *Pas);
} PasVTable;


typedef struct PasStruct{
    PasVTable *vTable;
    int godine;
    const char* vlasnik;
    int godineVlasnika;
} Pas;

void ispisiPodatkeOPsu(void *pasVoid){
    Pas *pas = (Pas*)pasVoid;
    printf("Pas ima %d godina, vlasnik se zove %s, vlasnik ima %d godina. \n", pas->godine, pas->vlasnik, pas->godineVlasnika);
}

int dajGodinePsa(void *pasVoid){
    Pas *pas = (Pas*) pasVoid;
    return pas->godine;
}

bool daLiJeVlasnikStariji(Pas *pas){
    return pas->godineVlasnika >= pas->godine;
}

struct PasVTableStruct pasVTableGlobal = {
    ispisiPodatkeOPsu,
    dajGodinePsa,
    daLiJeVlasnikStariji
};


Pas* Pas_new(int godine){
    Pas *z = (Pas*) malloc(sizeof(Pas));
    z->vTable = (&pasVTableGlobal);
}

Pas *Pas_new_sve(int godine, int godineVlasnika, char* imeVlasnika){
    Pas *pas = (Pas*) malloc(sizeof(Pas));
    pas->godine = godine;
    pas->godineVlasnika = godineVlasnika;
    pas->vlasnik = imeVlasnika;
    pas->vTable = &pasVTableGlobal;
}

Homophony