这个问题已经在这里有一个答案：
- 面向对象的用C 21回答
是否有可能用C来模拟继承？ 怎么样？ 示例代码会有所帮助。
编辑：我期待继承数据和方法。 集装箱本身并不能帮助。 可替代性 - 使用任何派生类对象，其中一个基类对象的工作 - 正是我需要的。
Answer 1:
这是非常简单的是这样的：
struct parent {
int foo;
char *bar;
};
struct child {
struct parent base;
int bar;
};
struct child derived;
derived.bar = 1;
derived.base.foo = 2;
但是如果你使用MS扩展（GCC中使用-fms-extensions标记），您可以使用匿名嵌套struct S和它看起来要好得多：
struct child {
struct parent; // anonymous nested struct
int bar;
};
struct child derived;
derived.bar = 1;
derived.foo = 2; // now it is flat
Answer 2:
可以肯定的（有点）面向对象的风格写C。
封装可以通过保持你的结构定义在.c文件，而不是在相关的标题来完成。 然后对外部世界通过保持指向他们处理你的对象，你提供的功能接受这样的指针作为你的对象的“方法”。
多态性样的行为可以通过使用函数指针，通常是“作战工程”内分组，有点像在C ++对象（或任何它被称为）“虚拟方法表”中获得。 所述OPS结构还可以包括其它的东西，如它的值是特定于给定“子类”的常数。 “父”结构可通过通用保持到特定OPS-数据的参考void*指针。 当然，“子”可能重复模式继承的多个级别。
因此，在下面的例子中， struct printer类似于一个抽象类，通过填写其可以“源自” pr_ops结构，并提供一个构造函数包裹pr_create() 各亚型将具有其自身的结构将被“锚定”到struct printer通过对象data通用指针。 这是由demontrated fileprinter亚型。 人们可以想像一个GUI或基于Socket的打印机，将不考虑由代码作为其余被操纵struct printer *引用。
Printer.h中：
struct pr_ops {
void (*printline)(void *data, const char *line);
void (*cleanup)(void *data);
};
struct printer *pr_create(const char *name, const struct output_ops *ops, void *data);
void pr_printline(struct printer *pr, const char *line);
void pr_delete(struct printer *pr);
printer.c：
#include "printer.h"
...
struct printer {
char *name;
struct pr_ops *ops;
void *data;
}
/* constructor */
struct printer *pr_create(const char *name, const struct output_ops *ops, void *data)
{
struct printer *p = malloc(sizeof *p);
p->name = strdup(name);
p->ops = ops;
p->data = data;
}
void pr_printline(struct printer *p, const char *line)
{
char *l = malloc(strlen(line) + strlen(p->name) + 3;
sprintf(l, "%s: %s", p->name, line);
p->ops->printline(p->data, l);
}
void pr_delete(struct printer *p)
{
p->ops->cleanup(p->data);
free(p);
}
最后，fileprinter.c：
struct fileprinter {
FILE *f;
int doflush;
};
static void filepr_printline(void *data, const char *line)
{
struct fileprinter *fp = data;
fprintf(fp->f, "%s\n", line);
if(fp->doflush) fflush(fp->f);
}
struct printer *filepr_create(const char *name, FILE *f, int doflush)
{
static const struct ops = {
filepr_printline,
free,
};
struct *fp = malloc(sizeof *fp);
fp->f = f;
fp->doflush = doflush;
return pr_create(name, &ops, fp);
}
Answer 3:
是的，你可以使用“双关型”技术模仿传承恩℃。 即派生类内的基类（结构）的声明，并浇铸派生作为基础：
struct base_class {
int x;
};
struct derived_class {
struct base_class base;
int y;
}
struct derived_class2 {
struct base_class base;
int z;
}
void test() {
struct derived_class d;
struct derived_class2 d2;
d.base.x = 10;
d.y = 20;
printf("x=%i, y=%i\n", d.base.x, d.y);
}
但是，你必须申报在第一位置的基类中派生你的结构，如果你想投的衍生为程序的基础：
struct base *b1, *b2;
b1 = (struct base *)d;
b2 = (struct base *)d2;
b1->x=10;
b2->x=20;
printf("b1 x=%i, b2 x=%i\n", b1->x, b2->x);
在这个片段中，你只能使用基类。
我用这个技术在我的项目： oop4c
Answer 4:
由于C ++的早期版本中，主要是转换成C的预处理器，它的deinitely可能。
Answer 5:
它应该是可能的，至少在一定程度上。
究竟你需要建模？ 数据或方法的继承？
编辑 ：这就是我发现了一个很短的文章： http://fluff.info/blog/arch/00000162.htm
Answer 6:
我使用的对象系统用C所使用后期绑定的方法，这允许对象的定向反射。
你可以阅读一下这里 。
Answer 7:
此链接可能是有用的- > 链接
基本的例子会像如下
struct BaseStruct
{
// some variable
}
struct DerivedStruct
{
struct BaseStruct lw;
// some more variable
};
Answer 8:
#include <stdio.h>
///////Class Cobj
typedef struct Cobj{
int x;
void (*setptr)(char * s,int val);
int (*getptr)(char * s);
} Cobj;
void set(char * s,int val)
{
Cobj * y=(Cobj *)s;
y->x=val;
}
int get(char * s){
Cobj * y=(Cobj *)s;
return y->x;
}
///////Class Cobj
Cobj s={12,set,get};
Cobj x;
void main(void){
x=s;
x.setptr((char*)&x,5);
s.setptr((char*)&s,8);
printf("%d %d %d",x.getptr((char*)&x),s.getptr((char*)&s) ,sizeof(Cobj));
}
文章来源: How can Inheritance be modelled using C? [duplicate]
