Simulating dynamic polymorphism in C

Question

This code snippet is a research attempt to find means for dealing with dynamic polymorphism (in C): two or more related "classes" share a common interface. Here is my best shot:

#include <stdio.h>
#include <stdlib.h>
#define CALL(INTERFACE_PTR, METHOD_NAME, ...) \
INTERFACE_PTR->METHOD_NAME(INTERFACE_PTR->object, ##__VA_ARGS__)
#define DESTRUCT(INTERFACE_PTR) INTERFACE_PTR->destruct(INTERFACE_PTR->object)
/*******************************************************************************
* Dummy data structures used for the demonstration. *
*******************************************************************************/
typedef struct int_triple {
 int a;
 int b;
 int c;
} int_triple;
typedef struct int_pointer_triple {
 int* a;
 int* b;
 int* c;
} int_pointer_triple;
void int_triple_init(int_triple* it)
{
 it->a = 0;
 it->b = 0;
 it->c = 0;
}
void int_pointer_triple_init(int_pointer_triple* ipt)
{
 ipt->a = malloc(sizeof(int));
 ipt->b = malloc(sizeof(int));
 ipt->c = malloc(sizeof(int));
 *ipt->a = 0;
 *ipt->b = 0;
 *ipt->c = 0;
}
void int_triple_set(void* int_triple_ptr, int a, int b, int c)
{
 int_triple* it = (int_triple*) int_triple_ptr;
 it->a = a;
 it->b = b;
 it->c = c;
 printf("int_triple_set(%d, %d, %d)\n", a, b, c);
}
void int_pointer_triple_set(void* int_triple_pointer_ptr, int a, int b, int c)
{
 int_pointer_triple* ipt = (int_pointer_triple*) int_triple_pointer_ptr;
 *ipt->a = a;
 *ipt->b = b;
 *ipt->c = c;
 printf("int_pointer_triple_set(%d, %d, %d)\n", a, b, c);
}
int int_triple_get_sum(void* int_triple_ptr)
{
 int_triple* it = (int_triple*) int_triple_ptr;
 puts("int_triple_get_sum()");
 return it->a + it->b + it->c;
}
int int_pointer_triple_get_sum(void* int_pointer_triple_ptr)
{
 int_pointer_triple* ipt = (int_pointer_triple*) int_pointer_triple_ptr;
 puts("int_pointer_triple_get_sum()");
 return *ipt->a + *ipt->b + *ipt->c;
}
int int_triple_get_product(void* int_triple_ptr)
{
 int_triple* it = (int_triple*) int_triple_ptr;
 puts("int_triple_get_product()");
 return it->a * it->b * it->c;
}
int int_pointer_triple_get_product(void* int_pointer_triple_ptr)
{
 int_pointer_triple* ipt = (int_pointer_triple*) int_pointer_triple_ptr;
 puts("int_pointer_triple_get_product()");
 return *ipt->a * *ipt->b * *ipt->c;
}
void int_triple_destruct(void* int_triple_ptr)
{
 free(int_triple_ptr);
 puts("int_triple_destruct()");
}
void int_pointer_triple_destruct(void* int_pointer_triple_ptr)
{
 int_pointer_triple* ipt = (int_pointer_triple*) int_pointer_triple_ptr;
 free(ipt->a);
 free(ipt->b);
 free(ipt->c);
 free(ipt);
 puts("int_pointer_triple_destruct");
}
/*******************************************************************************
* Interface stuff. *
*******************************************************************************/
typedef struct int_triple_interface {
 void* object;
 void (*set) (void*, int, int, int);
 int (*get_sum) (void*);
 int (*get_product) (void*);
 void (*destruct) (void*);
} int_triple_interface;
int_triple_interface* new_int_triple()
{
 int_triple_interface* interface = malloc(sizeof(*interface));
 int_triple* it = malloc(sizeof(*it));
 int_triple_init(it);
 interface->object = it;
 interface->set = int_triple_set;
 interface->get_sum = int_triple_get_sum;
 interface->get_product = int_triple_get_product;
 interface->destruct = int_triple_destruct;
 return interface;
}
int_triple_interface* new_int_pointer_triple()
{
 int_triple_interface* interface = malloc(sizeof(*interface));
 int_pointer_triple* ipt = malloc(sizeof(*ipt));
 int_pointer_triple_init(ipt);
 interface->object = ipt;
 interface->set = int_pointer_triple_set;
 interface->get_sum = int_pointer_triple_get_sum;
 interface->get_product = int_pointer_triple_get_product;
 interface->destruct = int_pointer_triple_destruct;
 return interface;
}
int main() {
 int_triple_interface* interface;
 int sum;
 int product;
 puts("--- int_triple ---");
 interface = new_int_triple();
 CALL(interface, set, 2, 3, 4);
 sum = CALL(interface, get_sum);
 product = CALL(interface, get_product);
 DESTRUCT(interface);
 printf("sum = %d, product = %d.\n", sum, product);
 puts("\n--- int_pointer_triple ---");
 interface = new_int_pointer_triple();
 CALL(interface, set, 5, 6, 7);
 sum = CALL(interface, get_sum);
 product = CALL(interface, get_product);
 DESTRUCT(interface);
 printf("sum = %d, product = %d.\n", sum, product);
}

The output from the main is as follows:

--- int_triple ---
int_triple_set(2, 3, 4)
int_triple_get_sum()
int_triple_get_product()
int_triple_destruct()
sum = 9, product = 24.
--- int_pointer_triple ---
int_pointer_triple_set(5, 6, 7)
int_pointer_triple_get_sum()
int_pointer_triple_get_product()
int_pointer_triple_destruct
sum = 18, product = 210.

Critique request

I would like to hear comments on:

1. naming conventions,
2. coding conventions,
3. overall comments,
4. design pattern,
5. anything else.

Answer 1

Your approach has at least two unfortunate aspects:

• Your approach to interface->object uses an extra heap-allocation.
• Adding a new "method" to int_triple_interface requires increasing the size of every "int triple" "object" in the program by sizeof(void(*)()).
• Nit: Your DESTRUCT(x) macro doesn't actually free(x).

The first problem could be solved by allocating the "object data" directly after the "interface data", with allowances for alignment/padding:

void int_triple_destruct(void* int_triple_ptr)
{
 puts("int_triple_destruct() is now a no-op");
}
int_triple_interface* new_int_triple()
{
 int_triple_interface* interface = malloc(sizeof(*interface) + sizeof(int_triple));
 int_triple* it = (void*)(interface + 1);
 int_triple_init(it);
 interface->object = it;
 interface->set = int_triple_set;
 interface->get_sum = int_triple_get_sum;
 interface->get_product = int_triple_get_product;
 interface->destruct = int_triple_destruct;
 return interface;
}

The second problem could be solved by storing all your function pointers away in a static data table: one table per object type, instead of one table per object instance.

#define CALL(INTERFACE_PTR, METHOD_NAME, ...) \
INTERFACE_PTR->vtable->METHOD_NAME(INTERFACE_PTR->object, ##__VA_ARGS__)
#define DESTRUCT(INTERFACE_PTR) INTERFACE_PTR->vtable->destruct(INTERFACE_PTR->object)
typedef struct {
 void (*set) (void*, int, int, int);
 int (*get_sum) (void*);
 int (*get_product) (void*);
 void (*destruct) (void*);
} int_triple_vtable_t;
int_triple_vtable_t int_triple_vtable = {
 int_triple_set,
 int_triple_get_sum,
 int_triple_get_product,
 int_triple_destruct,
};
typedef struct {
 void* object;
 int_triple_vtable_t* vtable;
} int_triple_interface;
int_triple_interface* new_int_triple()
{
 int_triple_interface* interface = malloc(sizeof(*interface) + sizeof(int_triple));
 int_triple* it = (void*)(interface + 1);
 int_triple_init(it);
 interface->object = it;
 interface->vtable = int_triple_vtable;
 return interface;
}

You probably don't really need the object pointer at all (since now it just points to (char *)interface + k for some known offset k), but I haven't thought about it too much.

---

In general, the question "how do I do OOP in C" can be answered by looking at what C++ does and then slavishly copying it. That's where I got the idea of "vtables" here, for example. Your object pointer is roughly equivalent to a C++ "virtual base class". And if you really want to do efficient, type-safe OOP in C, you're eventually going to have to reckon with the concepts of "copy construction" and "move construction", both of which you can find implemented in C++.