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

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

特性

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

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

•类的单一继承

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

•实现异常(纯C!)

•类的虚函数

•易于类实现的外部工具

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

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

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

有几种技术可以使用。最重要的是如何分割项目。我们在项目中使用的接口是在.h文件中声明的，对象的实现是在.c文件中。重要的部分是，所有包含.h文件的模块都只将对象视为void *，而.c文件是唯一知道结构内部的模块。

以FOO类为例:

在。h文件中

#ifndef FOO_H_
#define FOO_H_

...
 typedef struct FOO_type FOO_type;     /* That's all the rest of the program knows about FOO */

/* Declaration of accessors, functions */
FOO_type *FOO_new(void);
void FOO_free(FOO_type *this);
...
void FOO_dosomething(FOO_type *this, param ...):
char *FOO_getName(FOO_type *this, etc);
#endif

C实现文件就像这样。

#include <stdlib.h>
...
#include "FOO.h"

struct FOO_type {
    whatever...
};


FOO_type *FOO_new(void)
{
    FOO_type *this = calloc(1, sizeof (FOO_type));

    ...
    FOO_dosomething(this, );
    return this;
}

因此，我明确地将指针指向该模块的每个函数。c++编译器隐式地完成它，而在C中我们显式地将它写出来。

我真的在我的程序中使用了这个，以确保我的程序不是用c++编译的，而且它在我的语法高亮编辑器中有另一种颜色的良好属性。

FOO_struct的字段可以在一个模块中修改，而另一个模块甚至不需要重新编译就仍然可用。

通过这种风格，我已经处理了OOP(数据封装)的很大一部分优点。通过使用函数指针，甚至可以很容易地实现继承之类的东西，但老实说，它真的很少有用。

动物和狗的小例子:你镜像了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编译器上运行应该很容易。

你可以使用函数指针来伪装它，事实上，我认为理论上可以将c++程序编译成C语言。

然而，将一种范式强加于一种语言，而不是选择一种使用范式的语言，很少有意义。

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