我的一个面向对象的C语言宏定义系统

参考了网上很多人的代码，不一一列举了

/* ========================================================================  */
/* 这一区块定义下面用到的一些名字组成宏 */
/* 类方法名字拼接 */
#define METHOD(class, method)               class##_##method
/* 类方法的类型的名字拼接 */
#define METHOD_TYPE(class, method)          __##class##_##method##_typedef__
/* 类的虚函数表结构的名字拼接 */
#define VTBL_STRU_NAME(class)               __##class##_v_func_tbl__
/* 类的虚函数在虚函数表中的位置的名字拼接 */
#define VTBL_FUNC_PTR_NAME(class, func)     __##class##_fp_##func##_offset__
/* 类的虚函数表实体的名字拼接 */
#define VTBL_ENTITY_NAME(class)             __##class##_vtable_array__
/* 类的虚函数表实体初始化函数的名字拼接 */
#define VTBL_ENTITY_INIT_METHOD(class)      __##class##_class_vtable_init__
/* 类的虚函数表实体是否初始化OK的名字拼接 */
#define VTBL_ENTITY_IS_INIT_FLAG(class)     __##class##_class_vtable_is_init__
/* 类的虚函数表实体初始化结构变量的名字拼接 */
#define VTBL_ENTITY_INIT_STRU_VAR(class)    class##_class_vtable_init_info
/* 获取类的虚函数表初始化函数的指针 */
#define VTBL_ENTITY_INIT_METHOD_PTR(class)  ( VTBL_ENTITY_INIT_STRU_VAR(class) . vtable_init_method)
/* ========================================================================  */

/* ========================================================================  */
/* 创建接口 */
#define new(class)                   METHOD(class, create)()
/* 释放接口 */
#define delete(class, object)        METHOD(class, destory)(object)
/* ========================================================================  */

/* ========================================================================  */
/* 类声明的开始宏 */
#define BEGIN_CLASS(class)                                          \
    struct class;                                                   \
    typedef struct class class;                                     \
    struct VTBL_STRU_NAME(class);                                   \
    extern class_vtable_init VTBL_ENTITY_INIT_STRU_VAR(class);      \
    class * METHOD(class, create)(void);                            \
    int  METHOD(class, constructor)(class* this);                   \
    void METHOD(class, destory)(class* this);                       \
    int  METHOD(class, destructor)(class* this);                    \
    struct class

/* 继承自父类的声明 */
#define INHERITED_PARENT(p_class)                           \
        p_class parent

/* 类中的虚函数声明开始宏 */
#define BEGIN_V_METHOD_DEFINE(class)                        \
        struct VTBL_STRU_NAME(class)

/* 类继承自父类的虚函数信息 */
#define INHERITED_V_METHOD(p_class)                         \
            struct VTBL_STRU_NAME(p_class) parent_vtbl

/* 单个虚函数声明处 */
#define DEFINE_V_METHOD(ret_type, method)                   \
            ret_type (* method )(void* this, ...)

/* 类中的虚函数声明结束宏 */
#define END_V_METHOD_DEFINE(class)

/* 根类的对象声明 */
#define ROOT_CLASS_DECLARE(class)                           \
    struct VTBL_STRU_NAME(class) *vbtl;

/* 类中的声明结束宏 */
#define END_CLASS(class)
/* ========================================================================  */

/* 虚拟函数指针的使用 */
#define GET_V_METHOD_PTR(class, func)                                       \
        ( VTBL_FUNC_PTR_NAME(class, func) )

/* 定义虚拟函数的类型 */
#define DEFINE_V_METHOD_TYPE(ret_type, class, method)                       \
    typedef ret_type (* METHOD_TYPE(class, method) )

/* 定义虚拟函数的指针 */
#define DEFINE_V_METHOD_PTR(class, method)                                  \
    enum { VTBL_FUNC_PTR_NAME(class, method) =                              \
        (((int )(&((struct VTBL_STRU_NAME(class) *)0)-> method ))           \
                / sizeof(std_func_ptr)) + 1 };                              \

/* 定义继承的虚拟函数的指针 */
#define INHERITED_V_METHOD_PTR(class, parent, method)                       \
    enum { VTBL_FUNC_PTR_NAME(class, method) =                              \
                VTBL_FUNC_PTR_NAME(parent, method) };                       \

/* 定义普通的虚拟函数的信息 */
#define DEFINE_V_METHOD_INFO(ret_type, class, method)                       \
    DEFINE_V_METHOD_PTR(class, method);                                     \
    DEFINE_V_METHOD_TYPE(ret_type, class, method)

/* 定义继承的虚拟函数的信息 */
#define INHERITED_V_METHOD_INFO(ret_type, class, parent, method)            \
    INHERITED_V_METHOD_PTR(class, parent, method);                          \
    DEFINE_V_METHOD_TYPE(ret_type, class, method)

/* 定义普通的成员函数的信息 */
#define DEFINE_C_METHOD_INFO(ret_type, class, method)                       \
    extern ret_type METHOD(class, method)
/*
#define DEFINE_C_METHOD_INFO(ret_type, class, method)                       \
    extern common_func_ptr __##class##_##method##_ptr__;                    \
    typedef ret_type (* VTBL_FUNC_PTR_NAME(class, func) )
*/

/* 调用对象的虚拟函数 */
#define CALL_V_METHOD(object, class, method)                                \
    (*(((*( METHOD_TYPE(class, method) **) object ))[ GET_V_METHOD_PTR(class,method) - 1 ]))

/* 调用对象的普通成员函数 */
#define CALL_C_METHOD(object, class, method)                                \
            METHOD(class, method)
/*
#define DECLARE_V_METHOD(ret_type, class, method)                           \
    ret_type METHOD(class, method)

#define DECLARE_C_METHOD(ret_type, class, method)                           \
    common_func_ptr __##class##_##method##_ptr__ = METHOD(class, method);   \
    ret_type METHOD(class, method)

#define CALL_C_METHOD(ret_type, class, method)                              \
    *(VTBL_FUNC_PTR_NAME(class, method)__##class##_##method##_ptr__)
*/

/* ========================================================================  */
/* 实现类，主要是绑定类的虚拟函数指针 */
#define BEGIN_DECLARE_CLASS_VTABLE(class)                                   \
    static std_func_ptr VTBL_ENTITY_NAME(class) [                           \
        sizeof(struct VTBL_STRU_NAME(class) )/sizeof(std_func_ptr)] = {0};  \
    static char VTBL_ENTITY_IS_INIT_FLAG(class) = 0;                        \
    static int VTBL_ENTITY_INIT_METHOD(class) (std_func_ptr *vtbl)          \
    {                                                                       \
        if (0 != VTBL_ENTITY_IS_INIT_FLAG(class) ) return 1;                \
        if (0 == vtbl) return 0;                                            \
        do

/* 继承父类的VTABLE */
#define INHERITED_VTABLE_INIT(parent)                                       \
        if (0 == VTBL_ENTITY_INIT_METHOD_PTR(parent) (vtbl)) return 0

/* 继承的虚函数表项初始化 */
#define INHERITED_VTABLE_METHOD_INIT(class, parent, method)                 \
        vtbl[((int )(&((struct VTBL_STRU_NAME(parent) * )0)-> method ))     \
                    / sizeof(std_func_ptr)]                                 \
            = (std_func_ptr) METHOD(class, method)

/* 自身的虚函数表项初始化 */
#define SELF_VTABLE_METHOD_INIT(class, method)                              \
            INHERITED_VTABLE_METHOD_INIT(class, class, method)

/* 实现类的结束宏 */
#define END_DECLARE_CLASS_VTABLE(class)                                     \
        while(0);                                                           \
        VTBL_ENTITY_IS_INIT_FLAG(class) = 1;                                \
        return 1;                                                           \
    }                                                                       \
    class_vtable_init VTBL_ENTITY_INIT_STRU_VAR(class) =                    \
              {VTBL_ENTITY_INIT_METHOD(class), VTBL_ENTITY_NAME(class)};

/* ========================================================================  */

/* ========================================================================  */
/* 类的构造函数，主要提供两个接口：
   一个是create，以支持new，
   一个是constructor，就是构造并初始化的函数 */
#define BEGIN_CONSTRUCTOR(class, parent)                                    \
    extern int METHOD(class, constructor) (class * this);                   \
    class* METHOD(class, create) (void)                                     \
    {                                                                       \
        return common_create_object(sizeof( class ),                        \
            (std_func_ptr) METHOD(class, constructor));                     \
    }                                                                       \
                                                                            \
    int METHOD(class, constructor) (class * this)                           \
    {                                                                       \
        VTBL_ENTITY_INIT_METHOD(class) ( VTBL_ENTITY_NAME(class) );         \
        if (0 != METHOD(parent, constructor) (( parent *)(this)))           \
            return 1;                                                       \
        *(struct  VTBL_STRU_NAME(class) **)this =                           \
            (struct VTBL_STRU_NAME(class) *) VTBL_ENTITY_NAME(class) ;      \
        do                                                                  \

/* 类构造函数的结束宏 */
#define END_CONSTRUCTOR(class, parent)                                      \
        while(0);                                                           \
        return 0;                                                           \
    }
/* 根类的父类构造函数为0 */
#define void_constructor(this)          (0)
/* ========================================================================  */

/* ========================================================================  */
/* 类的析构函数，主要提供两个接口：
    一个是destory，以支持delete，
    一个是destructor，就是析构函数 */
#define BEGIN_DESTRUCTOR(class, parent)                                     \
    extern int METHOD(class, destructor) (class * this);                    \
    void METHOD(class, destory) ( class * this)                             \
    {                                                                       \
        common_destory_object( this ,                                       \
            (std_func_ptr) METHOD(class, destructor) );                     \
    }                                                                       \
                                                                            \
    int METHOD(class, destructor) (class * this)                            \
    {                                                                       \
        do                                                                  \

/* 类析构函数的结束宏 */
#define END_DESTRUCTOR(class, parent)                                       \
        while(0);                                                           \
        if (0 != METHOD(parent, destructor) (( parent *)(this)))            \
            return 1;                                                       \
        return 0;                                                           \
    }
/* 根类的父类析构函数为0 */
#define void_destructor(this)          (0)

/* ========================================================================  */

typedef int (*std_func_ptr)(void*);
typedef int (*common_func_ptr)(void*, ...);

typedef struct
{
    int (*vtable_init_method)(std_func_ptr*); 
    std_func_ptr vtable_array;
}class_vtable_init;

void* common_create_object(unsigned int size, std_func_ptr pCtor);
void  common_destory_object(void* this, std_func_ptr pDtor);
void  common_destory_object_non_virtual(void* this, std_func_ptr pDtor);

/* Null类，应该为所有类的虚根 */
BEGIN_CLASS(NullClass)
{
    /* 类自身的数据 */
    ROOT_CLASS_DECLARE(NullClass)
    /* 虚拟函数表的定义处 */
    BEGIN_V_METHOD_DEFINE(NullClass)
    {
        /* 自身的虚函数 */
        DEFINE_V_METHOD(int, destructor);
    }
    END_V_METHOD_DEFINE(NullClass);
}
END_CLASS(NullClass);

DEFINE_V_METHOD_INFO(int , NullClass, destructor) (NullClass* this);

/* 测试的第一个类 */
BEGIN_CLASS(TestClass)
{
    /* 继承自NullClass */
    INHERITED_PARENT(NullClass);

    /* 虚拟函数表的定义处 */
    BEGIN_V_METHOD_DEFINE(TestClass)
    {
        /* 继承自NullClass */
        INHERITED_V_METHOD(NullClass);
        /* 自身的虚函数 */
        DEFINE_V_METHOD(int, open) ;
        DEFINE_V_METHOD(void, close);
    }
    END_V_METHOD_DEFINE(TestClass);

    /* 类自身的数据 */
    int x_pThis;
}
END_CLASS(TestClass);

INHERITED_V_METHOD_INFO(int , TestClass, NullClass, destructor) (TestClass* this);
DEFINE_V_METHOD_INFO(int,  TestClass, open) (TestClass* this, char* filename);
DEFINE_V_METHOD_INFO(void, TestClass, close) (TestClass* this,  int handle);

/* 继承上一个类 */
BEGIN_CLASS(InheritClass)
{
    /* TestClass */
    INHERITED_PARENT(TestClass);

    /* 虚拟函数表的定义处 */
    BEGIN_V_METHOD_DEFINE(InheritClass)
    {
        /* 继承自TestClass */
        INHERITED_V_METHOD(TestClass);
        /* 自身的虚函数 */
        DEFINE_V_METHOD(int, seek) ;
    }
    END_V_METHOD_DEFINE(InheritClass);

    /* 类自身的数据 */
    int x_nOffset;
}
END_CLASS(InheritClass);

INHERITED_V_METHOD_INFO(void, InheritClass, TestClass, destructor)(InheritClass* this);
INHERITED_V_METHOD_INFO(void, InheritClass, TestClass, close)(InheritClass* this,  int handle);
DEFINE_V_METHOD_INFO(int,     InheritClass, seek)(InheritClass* this, int handle, int offset);

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

void* common_create_object(unsigned int size, std_func_ptr pCtor)
{
    /* 分配对象 */
    void* object = malloc(size);
    /* 如果分配失败，返回0 */
    if (0 == object)
        return 0;
    /* 调用构造函数 */
    if (0 != (*pCtor)(object))
    {
        /* 构造函数执行失败，释放对象 */
        free(object);
        return 0;
    }
    /* 成功，返回对象 */
    return object;
}

void  common_destory_object(void* this, std_func_ptr pDtor)
{
    /* 如果对象为空 */
    if (0 == this)  return;
    /* 如果存在虚函数表指针 */
    if (0 != *(void**)this)
    {
        /* 调用虚函数表中的第一个函数指针，默认此函数为析构函数 */
        if (0 != (*((*(std_func_ptr**)this)[0]))((void*)this))
            return;
    }
    else
    {
        /* 不为空，则调用传入的析构函数指针 */
        if (0 != (*pDtor)(this))
            return;
    }
    /* 最后释放对象 */
    free(this);
}

void  common_destory_object_non_virtual(void* this, std_func_ptr pDtor)
{
    if (0 == this)  return;
    if (0 != (*pDtor)(this))
        return;
    /* free */
    free(this);
}

BEGIN_DECLARE_CLASS_VTABLE(NullClass)
{
    SELF_VTABLE_METHOD_INIT(NullClass, destructor);
}
END_DECLARE_CLASS_VTABLE(NullClass)

BEGIN_CONSTRUCTOR(NullClass, void)
{
    /* do something */
    printf("call NullClass_constructor\n");
}
END_CONSTRUCTOR(NullClass, void)

BEGIN_DESTRUCTOR(NullClass, void)
{
    /* do something */
    printf("call NullClass_destructor\n");
}
END_DESTRUCTOR(NullClass, void)

int  METHOD(TestClass, open) (TestClass* this, char* filename)
{
    printf("call TestClass_open\n");
    return 0;
}

void METHOD(TestClass, close) (TestClass* this, int handle)
{
    printf("call TestClass_close\n");
    return;
}

BEGIN_DECLARE_CLASS_VTABLE(TestClass)
{
    INHERITED_VTABLE_INIT(NullClass);
    
    INHERITED_VTABLE_METHOD_INIT(TestClass, NullClass, destructor);
    
    SELF_VTABLE_METHOD_INIT(TestClass, open);
    SELF_VTABLE_METHOD_INIT(TestClass, close);
}
END_DECLARE_CLASS_VTABLE(TestClass)

BEGIN_CONSTRUCTOR(TestClass, NullClass)
{
    /* do something */
    printf("call TestClass_constructor\n");
    this->x_pThis = 0;
}
END_CONSTRUCTOR(TestClass, NullClass)

BEGIN_DESTRUCTOR(TestClass, NullClass)
{
    /* do something */
    printf("call TestClass_destructor\n");
    this->x_pThis = 0;
}
END_DESTRUCTOR(TestClass, NullClass)

int METHOD(InheritClass, seek) (InheritClass* this, int handle, int offset)
{
    printf("call InheritClass_seek\n");
    return 0;
}

void METHOD(InheritClass, close) (InheritClass* this, int handle)
{
    printf("call InheritClass_close\n");
    return;
}

BEGIN_DECLARE_CLASS_VTABLE(InheritClass)
{
    INHERITED_VTABLE_INIT(TestClass);
    
    INHERITED_VTABLE_METHOD_INIT(InheritClass, NullClass, destructor);
    INHERITED_VTABLE_METHOD_INIT(InheritClass, TestClass, close);
    
    SELF_VTABLE_METHOD_INIT(InheritClass, seek);
}
END_DECLARE_CLASS_VTABLE(InheritClass)

BEGIN_CONSTRUCTOR(InheritClass, TestClass)
{
    /* do something */
    printf("call InheritClass_constructor\n");
}
END_CONSTRUCTOR(InheritClass, TestClass)

BEGIN_DESTRUCTOR(InheritClass, TestClass)
{
    /* do something */
    printf("call InheritClass_destructor\n");
}
END_DESTRUCTOR(InheritClass, TestClass)

int main()
{
    TestClass* pTest;
    TestClass* pTest2;

    pTest = new(TestClass);

    //(*(((TestClass_ops*)(pTest->parent.vbtl))->open))(pTest, "");
    CALL_V_METHOD(pTest, TestClass, open)(pTest, "");
    //(*(((TestClass_ops*)(pTest->parent.vbtl))->close))(pTest, 1);
    CALL_V_METHOD(pTest, TestClass, close)(pTest, 1);

    delete(TestClass, pTest);
    printf("==========================================\n");

    pTest2 = new(InheritClass);
    //(*(((TestClass_ops*)(pTest2->parent.vbtl))->close))(pTest2, 1);
    CALL_V_METHOD(pTest2, TestClass, close)(pTest2, 1);
    //or
    CALL_V_METHOD(pTest2, InheritClass, close)(pTest2, 1);
    delete(InheritClass, pTest2);

    return 0;
}