我的一个面向对象的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;                                                   \

    typedefstruct 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)                         \
            structVTBL_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)

/*========================================================================*/typedefint (*std_func_ptr)(void*);

typedefint (*common_func_ptr)(void*, ...);



typedefstruct{int (*vtable_init_method)(std_func_ptr*); 

    std_func_ptr vtable_array;

}class_vtable_init;void* common_create_object(unsigned intsize, 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);/*类自身的数据*/
    intx_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,  inthandle);/*继承上一个类*/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);/*类自身的数据*/
    intx_nOffset;

}

END_CLASS(InheritClass);



INHERITED_V_METHOD_INFO(void, InheritClass, TestClass, destructor)(InheritClass* this);

INHERITED_V_METHOD_INFO(void, InheritClass, TestClass, close)(InheritClass* this,  inthandle);

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 intsize, 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, inthandle)

{

    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, intoffset)

{

    printf("call InheritClass_seek\n");return 0;

}void METHOD(InheritClass, close) (InheritClass* this, inthandle)

{

    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)intmain()

{

    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;

}