0 继承是OO设计的基础
继承是OO设计中的基本部分，也是实现多态的基础，C++，C#，Objective-C。Java。PHP。JavaScript等为OO而设计的语言，其语言本身对实现继承提供了直接支持。而遵循C/Unix设计哲学的语言，从不限定编程风格。并且提供了实现OO的基本支持。以下我们就来看看怎样用C语言实现继承。
1 内存布局层面上继承的含义
现在差点儿全部程序猿都知道继承的抽象含义，对于被用烂了的猫狗继承动物的样例也耳熟能详。在此，我们抛开抽象世界，深入到继承的详细实现上。当然不同的语言对继承的实现机制并不全然同样，可是了解当中一种典型的实现细节对于理解继承是很有优点的。这里我们以C++为例进行说明。
class B
{
int x;
int y;
int z;
};
class C : B
{
float f;
char s[10];
};上述代码表示子类C继承了父类B。以下是类C的一个实例（对象）的内存布局。
C对象有两部分组成，红色区域是继承自B的部分，蓝色区域是自身特有的。这样一来，红色部分全然能够当成是一个B类对象。
2 利用结构体实现继承的两种方法
2.1 父类对象作为子类的成员
理解了继承的内存布局原理之后，用C来实现继承就很easy了。最easy想到的方法例如以下：
struct B
{
int x;
int y;
int z;
};
struct C
{
struct B objB;
float f;
char s[10];
};上述代码通过在C中包括一个B类型的成员来实现继承，此方法很直接。但使用起来有一些不太方便。
struct C objC;
objC.objB.x = 10;
((struct B*)&objC)->x = 10;要想訪问父类的成员x，有两种方法。一种是objC.objB.x；还有一种是((struct B*)&objC)->x = 10。
这两种方式都看起来不够直接。而在子类方法中訪问父类成员是很频繁的。
void c_member_method(struct C* pObjC)
{
pObjC->objB.x = 20; /* 訪问父类成员 */
pObjC->f = 0.23f; /* 訪问自身成员 */
}第一种方法，感觉更像是OB风格。而不是OO。
另外一种方法，必须进行强制类型转换，感觉语法上不够美观。
2.2 子类包括全部的父类成员
struct C
{
int x;
int y;
int z;
float f;
char s[10];
};把全部的父类成员原样作为子类的成员。这样子类对象訪问继承来的成员就很直接了。
void c_member_method(struct C* pObjC)
{
pObjC->x = 20; /* 訪问父类成员 */
pObjC->f = 0.23f; /* 訪问自身成员 */
}
void main()
{
struct C objC;
objC.x = 10;
}看起来很好，实际上在project上会存在一个很大的问题：难以维护。比如，每当创建一个子类。必须原样书写全部的父类成员，当父类定义变动时，子类须要做出同样的改动。一旦父类稍具规模，维护这样的继承关系将是一场噩梦。
那么怎样解决的？
方法是现成的，那就是利用C语言的预处理宏定义#define. 例如以下所看到的：
#define B_STRUCT
int x;
int y;
int z
struct B
{
B_STRUCT;
};
struct C
{
B_STRUCT;
float f;
char s[10];
};当继承层级更深时。比如 C继承B，D继承C，能够照搬此方法。
#define B_STRUCT
int x;
int y;
int z
struct B
{
B_STRUCT;
};
#define C_STRUCT
B_STRUCT;
float f;
char s[10]
struct C
{
C_STRUCT;
};
#define D_STRUCT
C_STRUCT;
double d
struct D
{
D_STRUCT;
};通过宏定义。能够很easy实现和维护这样的继承关系。
3 方法（成员函数）的封装与继承
C语言中没有成员函数的概念，语言本身也不支持。
使用C语言实现真正的成员函数差点儿是不可能的，除非嵌入汇编语言。与其使用汇编语言，还不如直接使用C++呢。
所以，我们不追求形式上的成员函数，仅仅实现意义上的成员函数–（对给定类型对象进行操作）的函数，并使用带结构名前缀的函数名加以命名之。
我们还是以上面的样例进行说明。
typedef struct B B;
static void b_member_function(B* pobjB) /* 类B的成员函数 */
{
}
typedef struct C C;
static void c_member_function(C* pobjC) /* 类C的成员函数 */
{
}对成员函数的调用，有两种情形：（1）外部代码调用成员函数；（2）子类成员函数中调用父类的成员函数；
static void c_member_function(C* pobjC)
{
b_member_function((B*)pobjC); /* 子类成员函数内部调用父类成员函数 */
}
void main()
{
C* pObjC = malloc(sizeof(C));
b_member_function((B*)pObjC); /* 外部代码调用成员函数 */
free(pObjC);
}这两种情况都须要对实參进行强制类型转换为父类型。C编译器对类型继承关系一无所知，无法从语法上对继承进行自己主动支持，所以仅仅能手动强制类型转换了。
有些人喜欢更进一步模拟成员函数。把全部成员函数的地址作为指针类型的成员变量存储到结构体内部。
例如以下：
#define B_STRUCT
int x;
int y;
int z;
void (*pb_member_function1)(B*);
void (*pb_member_function2)(B*, int arg)
struct B
{
B_STRUCT;
};
/* 初始化B对象的同一时候初始化 */
B* b = malloc(sizeof(B));
b->pb_member_function1 = b_member_function1;
b->pb_member_function2 = b_member_function2;
/* 调用 */
b->b_member_function1(b);这样形式上更加接近“成员函数”。但同一时候也带来了额外的内存开销和代码量。
为了减小内存消耗，有人提出不再在对象中全然存放全部成员函数指针，而是仅仅存放一个指向成员函数地址列表的指针。毕竟，同一类型的全部实例（对象）共享同样的一组成员函数。
/* B类型的成员方法表 */
const struct B_MethodTable
{
void (*pb_member_function1)(B*);
void (*pb_member_function2)(B*, int arg);
}b_method_table{
b_member_function1,
b_member_function2,
};
#define B_STRUCT
int x;
int y;
int z;
struct B_MethodTable * pMethodTable;
struct B
{
B_STRUCT;
};
/* 初始化B对象的同一时候初始化 */
B* b = malloc(sizeof(B));
b->pMethodTable = &b_method_table;
/* 调用 */
b->pMethodTable->pb_member_function1(b);这样在一定程度上减小了内存占用量和代码量，可是队成员函数的调用写法却变得很繁琐不自然。
4 做到何种程度？
使用C语言做OO开发时，要掌握好一个度。不要过分追求对OO语言C++的模拟，全然模拟C++的话，还不如干脆直接使用C++。
- 有些语言特性无法模拟，如C++中private,protected等訪问限定符。成员函数的this指针。更应该注重意义上的模拟。通过一些命名规则和约定来达到OO。
- 永远不要违背C语言的设计哲学：程序猿控制一切，直接简明。
这个度的把握须要依据详细的项目规模和需求。是实践中摸索出来的。无法给出理论上的最优值。