我亲眼见过。我不推荐。c++最初是作为一个生成C代码的中间步骤的预处理器开始的。

本质上，您最终要做的是为所有方法创建一个调度表，其中存储函数引用。派生类需要复制这个分派表并替换您想要重写的条目，如果您的新“方法”想要调用基方法，则必须调用原始方法。最终，你要重写c++。

这本书读起来很有趣。我自己也在思考同样的问题，思考这个问题的好处是:

Trying to imagine how to implement OOP concepts in a non-OOP language helps me understand the strengths of the OOp language (in my case, C++). This helps give me better judgement about whether to use C or C++ for a given type of application -- where the benefits of one out-weighs the other. In my browsing the web for information and opinions on this I found an author who was writing code for an embedded processor and only had a C compiler available: http://www.eetimes.com/discussion/other/4024626/Object-Oriented-C-Creating-Foundation-Classes-Part-1

在他的案例中，用普通C语言分析和调整面向对象的概念是一种有效的追求。他似乎愿意牺牲一些面向对象的概念，因为尝试用C语言实现它们会带来性能开销。

我得到的教训是，是的，在某种程度上它是可以做到的，是的，有一些很好的理由去尝试。

In the end, the machine is twiddling stack pointer bits, making the program counter jump around and calculating memory access operations. From the efficiency standpoint, the fewer of these calculations done by your program, the better... but sometimes we have to pay this tax simply so we can organize our program in a way that makes it least susceptible to human error. The OOP language compiler strives to optimize both aspects. The programmer has to be much more careful implementing these concepts in a language like C.

动物和狗的小例子:你镜像了c++的虚表机制(基本上是这样)。你还分离了分配和实例化(Animal_Alloc, Animal_New)，所以我们不会多次调用malloc()。我们还必须显式地传递this指针。

如果你要做非虚函数，那就很简单了。你只是不需要将它们添加到虚函数表中，静态函数也不需要this指针。多重继承通常需要多个虚表来解决歧义。

此外，您应该能够使用setjmp/longjmp来进行异常处理。

struct Animal_Vtable{
    typedef void (*Walk_Fun)(struct Animal *a_This);
    typedef struct Animal * (*Dtor_Fun)(struct Animal *a_This);

    Walk_Fun Walk;
    Dtor_Fun Dtor;
};

struct Animal{
    Animal_Vtable vtable;

    char *Name;
};

struct Dog{
    Animal_Vtable vtable;

    char *Name; // Mirror member variables for easy access
    char *Type;
};

void Animal_Walk(struct Animal *a_This){
    printf("Animal (%s) walking\n", a_This->Name);
}

struct Animal* Animal_Dtor(struct Animal *a_This){
    printf("animal::dtor\n");
    return a_This;
}

Animal *Animal_Alloc(){
    return (Animal*)malloc(sizeof(Animal));
}

Animal *Animal_New(Animal *a_Animal){
    a_Animal->vtable.Walk = Animal_Walk;
    a_Animal->vtable.Dtor = Animal_Dtor;
    a_Animal->Name = "Anonymous";
    return a_Animal;
}

void Animal_Free(Animal *a_This){
    a_This->vtable.Dtor(a_This);

    free(a_This);
}

void Dog_Walk(struct Dog *a_This){
    printf("Dog walking %s (%s)\n", a_This->Type, a_This->Name);
}

Dog* Dog_Dtor(struct Dog *a_This){
    // Explicit call to parent destructor
    Animal_Dtor((Animal*)a_This);

    printf("dog::dtor\n");

    return a_This;
}

Dog *Dog_Alloc(){
    return (Dog*)malloc(sizeof(Dog));
}

Dog *Dog_New(Dog *a_Dog){
    // Explict call to parent constructor
    Animal_New((Animal*)a_Dog);

    a_Dog->Type = "Dog type";
    a_Dog->vtable.Walk = (Animal_Vtable::Walk_Fun) Dog_Walk;
    a_Dog->vtable.Dtor = (Animal_Vtable::Dtor_Fun) Dog_Dtor;

    return a_Dog;
}

int main(int argc, char **argv){
    /*
      Base class:

        Animal *a_Animal = Animal_New(Animal_Alloc());
    */
    Animal *a_Animal = (Animal*)Dog_New(Dog_Alloc());

    a_Animal->vtable.Walk(a_Animal);

    Animal_Free(a_Animal);
}

PS.这是在c++编译器上测试的，但是在C编译器上运行应该很容易。

看看GObject。它应该是C语言中的OO，是您正在寻找的东西的一个实现。如果你真的想要面向对象，那就使用c++或其他面向对象语言。如果您习惯了处理OO语言，那么GObject有时真的很难使用，但是像其他东西一样，您会习惯它的约定和流程。

这个问题的答案是“是的，你可以”。

面向对象的C (OOC)工具包是为那些希望以面向对象的方式进行编程的人准备的，但它也沿用了优秀的老C。OOC实现了类、单继承和多继承、异常处理。

特性

•只使用C宏和函数，不需要语言扩展!(ansi c)

•易于阅读的源代码为您的应用程序。小心翼翼地使事情尽可能简单。

•类的单一继承

•通过接口和mixin进行多重继承(从1.3版开始)

•实现异常(纯C!)

•类的虚函数

•易于类实现的外部工具

欲了解更多详情，请访问http://ooc-coding.sourceforge.net/。

似乎人们正在尝试用C来模仿c++风格。我的观点是，用C来做面向对象的编程实际上就是做面向结构的编程。但是，您可以实现后期绑定、封装和继承等功能。对于继承，在子结构中显式地定义一个指向基结构的指针，这显然是一种多重继承。你还需要确定你的

//private_class.h
struct private_class;
extern struct private_class * new_private_class();
extern int ret_a_value(struct private_class *, int a, int b);
extern void delete_private_class(struct private_class *);
void (*late_bind_function)(struct private_class *p);

//private_class.c
struct inherited_class_1;
struct inherited_class_2;

struct private_class {
  int a;
  int b;
  struct inherited_class_1 *p1;
  struct inherited_class_2 *p2;
};

struct inherited_class_1 * new_inherited_class_1();
struct inherited_class_2 * new_inherited_class_2();

struct private_class * new_private_class() {
  struct private_class *p;
  p = (struct private_class*) malloc(sizeof(struct private_class));
  p->a = 0;
  p->b = 0;
  p->p1 = new_inherited_class_1();
  p->p2 = new_inherited_class_2();
  return p;
}

    int ret_a_value(struct private_class *p, int a, int b) {
      return p->a + p->b + a + b;
    }

    void delete_private_class(struct private_class *p) {
      //release any resources
      //call delete methods for inherited classes
      free(p);
    }
    //main.c
    struct private_class *p;
    p = new_private_class();
    late_bind_function = &implementation_function;
    delete_private_class(p);

用c_compiler main.c inherited_class_1编译。obj inherited_class_2。obj private_class.obj。

因此，我的建议是坚持使用纯C风格，不要试图强行采用c++风格。此外，这种方式也有助于以一种非常干净的方式构建API。