lw_oopc（c语言实现面向过程宏文件）解析

一：计算结构体成员变量偏移量宏

#ifdef LW_OOPC_USE_USER_DEFINED_OFFSETOF
// 有些环境可能不支持，不过，这种情形极少出现
#define LW_OOPC_OFFSETOF(s,m) (size_t)&(((s*)0)->m)
#endif

二：INTERFACE接口：接口(interface)是我们java里的一个关键字，接口只能定义抽象方法不能实现方法，接口就是一种特殊的abstract class，但是比abstract class更加抽象。

INTERFACE(type) ：用来声明一个type型的的接口，并且声明相关函数。

#define INTERFACE(type)             \
typedef struct type type;           \
void type##_ctor(type* t);          \
int type##_dtor(type* t);           \
struct type

三：抽象类ABS_CLASS：抽象类既可以定义抽象方法，也可以实现方法。

ABS_CLASS(type)：用来声明一个type型的的抽象类，并且声明相关函数。

#define ABS_CLASS(type)             \
typedef struct type type;           \
void type##_ctor(type* t);          \
int type##_dtor(type* t);           \
void type##_delete(type* t);        \
struct type

四：类CLASS：类用来构造方法。

CLASS(type)：用来声明一个type型的的类，并且声明相关函数。指针的所占内存大小是恒定的，32位为4字节。

#define CLASS(type)                 \
typedef struct type type;           \
type* type##_new(lw_oopc_file_line_params); \
void type##_ctor(type* t);          \
int type##_dtor(type* t);           \
void type##_delete(type* t);        \
struct type

五：构造类CTOR

CTOR(type)  ：用来初始化一个类，即为这个类分配内存空间。

END_CTOR：构造结束。

#ifdef LW_OOPC_SUPPORT_MEMORY_LEAK_DETECTOR
#define CTOR(type)                                      \
    type* type##_new(const char* file, int line) {      \
    struct type *cthis;                                 \
    cthis = (struct type*)lw_oopc_malloc(sizeof(struct type), #type, file, line);   \
    if(!cthis)                                          \
    {                                                   \
        return ;                                       \
    }                                                   \
    type##_ctor(cthis);                                 \
    return cthis;                                       \
}                                                       \
                                                        \
void type##_ctor(type* cthis) {
#else
#define CTOR(type)                                      \
    type* type##_new() {                                \
    struct type *cthis;                                 \
    cthis = (struct type*)malloc(sizeof(struct type));  \
    if(!cthis)                                          \
    {                                                   \
        return ;                                       \
    }                                                   \
    type##_ctor(cthis);                                 \
    return cthis;                                       \
}                                                       \
                                                        \
void type##_ctor(type* cthis) {
#endif

#define END_CTOR    }

六：DTOR：用来支持析构的概念。

DTOR(type) ：释放一个类的内存空间。

END_DTOR：析构结束。

#define DTOR(type)                  \
void type##_delete(type* cthis)     \
{                                   \
        if(type##_dtor(cthis))      \
        {                           \
                lw_oopc_free(cthis);\
        }                           \
}                                   \
int type##_dtor(type* cthis)        \
{

#define END_DTOR }

注意：这里的int type##_dtor(type* cthis)是释放内存的函数，是由我们自己实现的。而与构造类里的void type##_ctor(type* cthis)不同，type##_ctor(type* cthis)实现方法是调用下面定义的一些宏。

七：ABS_CTOR：用来构造可被继承的抽象类。

ABS_CTOR(type)：用来初始化一个抽象类（基类）

END_ABS_CTOR：抽象类初始化结束。

#define ABS_CTOR(type)              \
void type##_ctor(type* cthis) {

#define END_ABS_CTOR }

八：FUNCTION_SETTING：关联类里的函数指针。

FUNCTION_SETTING(f1, f2)：对于抽象类既可以实现抽象方法，也可以实现具体的方法。对于具体的类实现具体的方法。

#define FUNCTION_SETTING(f1, f2)    cthis->f1 = f2;

九：#define IMPLEMENTS(type) struct type type和#define EXTENDS(type) struct type type都是用来实现继承的。

相当于在一个结构体里嵌套类另一个结构体(相当于父类)。

十:  #define SUPER_PTR(cthis, father) ((father*)(&(cthis->father)))

　　#define SUPER_PTR_2(cthis, father, grandfather) \
　　SUPER_PTR(SUPER_PTR(cthis, father), grandfather)

　　#define SUPER_PTR_3(cthis, father, grandfather, greatgrandfather) \
　　SUPER_PTR(SUPER_PTR_2(cthis, father, grandfather), greatgrandfather)

该结构体指向其里面的另一个结构体(相当于父类)，并且将其类型转换为父类指针，用于实例化方法。

十一：#define SUPER_CTOR(father)  father##_ctor(SUPER_PTR(cthis, father));

将继承类转换为被继承类，为了支持子类调用父类的构造函数。和第十点意思相同。

十二：#define SUB_PTR(selfptr, self, child) \

　　((child*)((char*)selfptr - LW_OOPC_OFFSETOF(child, self)))

　　#define SUB_PTR_2(selfptr, self, child, grandchild) \
　　SUB_PTR(SUB_PTR(selfptr, self, child), child, grandchild)

　　#define SUB_PTR_3(selfptr, self, child, grandchild, greatgrandchild) \
　　SUB_PTR(SUB_PTR_2(selfptr, self, child, grandchild), grandchild, greatgrandchild)

　　现在不知道具体作用

十三：#define INHERIT_FROM(father, cthis, field) cthis->father.field

用来访问子类成员。

#define ABS_CTOR(type)              \
void type##_ctor(type* cthis) {

#define END_ABS_CTOR }

#define FUNCTION_SETTING(f1, f2)    cthis->f1 = f2;

#define IMPLEMENTS(type)    struct type type

#define EXTENDS(type)        struct type type

#define SUPER_PTR(cthis, father) ((father*)(&(cthis->father)))

#define SUPER_PTR_2(cthis, father, grandfather) \
    SUPER_PTR(SUPER_PTR(cthis, father), grandfather)

#define SUPER_PTR_3(cthis, father, grandfather, greatgrandfather) \
    SUPER_PTR(SUPER_PTR_2(cthis, father, grandfather), greatgrandfather)

#define SUPER_CTOR(father) \
    father##_ctor(SUPER_PTR(cthis, father));

#define SUB_PTR(selfptr, self, child) \
    ((child*)((char*)selfptr - LW_OOPC_OFFSETOF(child, self)))

#define SUB_PTR_2(selfptr, self, child, grandchild) \
    SUB_PTR(SUB_PTR(selfptr, self, child), child, grandchild)

#define SUB_PTR_3(selfptr, self, child, grandchild, greatgrandchild) \
    SUB_PTR(SUB_PTR_2(selfptr, self, child, grandchild), grandchild, greatgrandchild)

#define INHERIT_FROM(father, cthis, field)    cthis->father.field