C with object inheritance

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


struct __attribute__((packed)) class_object
{
    void                        *handle;
    void                        *super;
    void                        (*destructor)(void*);
    size_t                      data_size;
    void                        *data_ptr;
};

#define object_reference(object)                                    \
    ((struct class_object*) (((char*) object) - sizeof(struct class_object)))

#define handle(object)                                              \
    (object_reference(object)->handle)


void __delete_object(void *object)
{
    free(((struct class_object*) object)->handle);
}


void __create_object(void *object, void *handle)
{
    struct class_object *this = object;
    this->handle = handle;
    this->super = object;
    this->destructor = __delete_object;
    this->data_size = 0;
    this->data_ptr = NULL;
}


#define define_class(name, base, type)                              \
    struct class_##name                                             \
    {                                                               \
        struct class_object     header;                             \
        type                    data;                               \
        struct class_##base     base_type;                          \
    }


#define class(name, base, type)                                     \
    struct class_##name;                                            \
                                                                    \
    void __delete_##name(void *object)                              \
    {                                                               \
        struct class_object *this = object;                         \
        delete_##name(this->data_ptr);                              \
        __delete_##base(this->super);                               \
    }                                                               \
                                                                    \
    type * __create_##name(void *object, void *handle)              \
    {                                                               \
        size_t class_size = sizeof(type);                           \
        size_t class_offset = sizeof(struct class_object);          \
        struct class_object *this = object;                         \
                                                                    \
        if (this == NULL)                                           \
        {                                                           \
            this = object = handle;                                 \
        }                                                           \
                                                                    \
        if (object == NULL)                                         \
        {                                                           \
            return NULL;                                            \
        }                                                           \
                                                                    \
        this->handle = handle;                                      \
        this->super = ((char*) object) + class_offset + class_size; \
        this->destructor = __delete_##name;                         \
        this->data_size = class_size;                               \
        this->data_ptr = ((char*) object) + class_offset;           \
                                                                    \
        __create_##base(this->super, handle);                       \
                                                                    \
        create_##name(this->data_ptr);                              \
                                                                    \
        return this->data_ptr;                                      \
    }                                                               \
                                                                    \
    define_class(name, base, type)


#define new(name)                                                   \
    __create_##name(NULL, malloc(sizeof(struct class_##name)))


#define del(object)                                                 \
    object_reference(object)->destructor(object_reference(object))


#define super(type, object)                                         \
    ((type *) ((struct class_object*) (object_reference(object)->super))->data_ptr)


struct A
{
    int member;
};

void create_A(struct A *this)
{
    this->member = 2;
    printf("A's ctor, member=%d\n", this->member);
}

void delete_A(struct A *this)
{
    printf("A's dtor, member=%d\n", this->member);
}

class(A, object, struct A);


struct B
{
    int member;
};

void create_B(struct B *this)
{
    super(struct A, this)->member = this->member = 3;
}

void delete_B(struct B *this)
{
    printf("B's dtor, B::member=%d A::member=%d\n", this->member, super(struct A, this)->member);
}

class(B, A, struct B);


int main()
{
    struct B *b = new(B);
    b->member = 5;

    del(b);
    return 0;
}