面向对象的C，可以做到，我在韩国看过这种类型的代码，这是我多年来见过的最可怕的怪物(这是去年(2007年)我看到的代码)。 所以，是的，这是可以做到的，是的，人们曾经这样做过，甚至在这个时代仍然这样做。但我还是推荐c++或Objective-C，这两种语言都起源于C，目的是用不同的范式提供面向对象。

是的，你可以。在c++或Objective-C出现之前，人们就开始编写面向对象的C语言了。在某种程度上，c++和Objective-C都试图采用C中使用的一些面向对象概念，并将它们形式化为语言的一部分。

这是一个非常简单的程序，它展示了如何创建一个看起来像方法调用的东西(有更好的方法可以做到这一点。这只是证明语言支持这些概念):

#include<stdio.h>

struct foobarbaz{
    int one;
    int two;
    int three;
    int (*exampleMethod)(int, int);
};

int addTwoNumbers(int a, int b){
    return a+b;
}

int main()
{
    // Define the function pointer
    int (*pointerToFunction)(int, int) = addTwoNumbers;

    // Let's make sure we can call the pointer
    int test = (*pointerToFunction)(12,12);
    printf ("test: %u \n",  test);

    // Now, define an instance of our struct
    // and add some default values.
    struct foobarbaz fbb;
    fbb.one   = 1;
    fbb.two   = 2;
    fbb.three = 3;

    // Now add a "method"
    fbb.exampleMethod = addTwoNumbers;

    // Try calling the method
    int test2 = fbb.exampleMethod(13,36);
    printf ("test2: %u \n",  test2);

    printf("\nDone\n");
    return 0;
}

是的，但我从未见过有人尝试用C实现任何类型的多态性。

C的stdio FILE子库是如何在纯C中创建抽象、封装和模块化的极好示例。

继承和多态性——通常被认为是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编译器上运行应该很容易。

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