C语言这样封装继承多态也挺好的。

#include <stdio.h>
#include <conio.h>
#define MAX 10

typedef struct Animal{
	void *this;
	char name[MAX];
	void (*shout)(struct Animal *);
}Animal;

typedef struct Swimmable{
	void *this;
	void (*swim)(struct Swimmable *);
}Swimmable;

typedef struct Dog{
	Animal *Animal;
	Swimmable *Swimmable;
}Dog;

typedef struct Cat{
	Animal *Animal;
	Swimmable *Swimmable;
}Cat;

void shout_Cat(Animal *cat){
	printf("%s miaomiao.\n", cat->name);
}

void swim_Cat(Swimmable *cat){
	printf("%s cannot swim.\n", ((Cat *)(cat->this))->Animal->name);
}

void shout_Dog(Animal *dog){
	printf("%s wangwang.\n", dog->name);
}

void swim_Dog(Swimmable *dog){
	printf("%s can swim.\n", ((Dog *)(dog->this))->Animal->name);
}

void visit_Animal(Animal *animal){
	animal->shout(animal);
}

void visit_Swimmable(Swimmable *swimmable){
	swimmable->swim(swimmable);
}

void initialize_Dog(Dog* dog, char *name){
	dog->Animal = (Animal *) malloc(sizeof(Animal));
	dog->Animal->this = dog;
	dog->Animal->shout = shout_Dog;
	strcpy(dog->Animal->name, name);
	dog->Swimmable = (Swimmable *) malloc(sizeof(Swimmable));
	dog->Swimmable->this = dog;
	dog->Swimmable->swim = swim_Dog;
}

void initialize_Cat(Cat* cat, char *name){
	cat->Animal = (Animal *) malloc(sizeof(Animal));
	cat->Animal->this = cat;
	cat->Animal->shout = shout_Cat;
	strcpy(cat->Animal->name, name);
	cat->Swimmable = (Swimmable *) malloc(sizeof(Swimmable));
	cat->Swimmable->this = cat;
	cat->Swimmable->swim = swim_Cat;
}

void finalize_Dog(Dog *dog){
	free(dog->Animal);
	free(dog->Swimmable);
}

void finalize_Cat(Cat *cat){
	free(cat->Animal);
	free(cat->Swimmable);
}

void main(){
	Dog dog;
	Cat cat;
	clrscr();
	initialize_Dog(&dog, "Wangcai");
	initialize_Cat(&cat, "Kitty");
	visit_Animal(dog.Animal);
	visit_Animal(cat.Animal);
	visit_Swimmable(dog.Swimmable);
	visit_Swimmable(cat.Swimmable);
	finalize_Dog(&dog);
	finalize_Cat(&cat);
}

所有的面向对象的设计模式也都能类似实现。
虽然没有C++那么方便地面向对象，但是灵活性更强，如可以让多个实例共享一个父实例等。

struct 在C++中就是全公开的类，所以封装性不强。

选择用哪个父类操作这个实例，就等于公开哪些接口，其他的接口外界同样也操作不到。

这样的结构只能说是组合不能说是继承吧，在继承的关系中cat和animal的关系应该是cat is a animal 而上面的结构是cat has a animal

这是 has-a 关系？

C其实引入这种东西有什么特别的用途呢》？》》

很有用途，C的这种函数指针表用的地方太多了。

理论上说，除了CPU某些特殊的指令，C能够做到所有的事情。
但是这样写不累吗。。。

除非是没有C++编译器，只好这样来实现类了。

组合能替代继承的原因就是因为他们在内部数据分布的一致性。所以看起来是has-a其实也是is-a，对C两不妨碍

在C插件体系下， 这么做很好的。 但是， 整个项目这么搞， 未必累了些咯。 特定的MODULE这么搞， 有利于开发。

void finalize_Cat(Cat *cat){ 
    free(cat->Animal); 
    free(cat->Swimmable); 
} 

memory leaking!