C 语言实现面向对象编程的核心思想与示例

3. 测试代码

#include <stdio.h>
#include "Animal.h"

int main() {
    // 栈上创建对象
    Animal a;
    // 构造对象
    Animal_Ctor(&a, 1, 3);
    printf("age = %d, weight = %d\n",
           Animal_GetAge(&a),
           Animal_GetWeight(&a));
    return 0;
}

在此模式下，this 指针显式传递，编译器不会自动处理，这要求开发者手动管理对象地址。

四、继承：结构体嵌套

C 语言没有直接的继承关键字，但可以通过在子类结构体的第一个成员放置父类结构体来实现。

1. 子类定义 (Dog.h)

#ifndef _DOG_H_
#define _DOG_H_

#include "Animal.h"

// 定义子类结构
typedef struct {
    Animal parent; // 第一个位置放置父类结构
    int legs;      // 子类特有属性
} Dog;

// 构造函数声明
void Dog_Ctor(Dog *this, int age, int weight, int legs);

// 属性访问声明
int Dog_GetAge(Dog *this);
int Dog_GetLegs(Dog *this);

#endif

2. 子类实现 (Dog.c)

#include "Dog.h"

// 构造函数实现
void Dog_Ctor(Dog *this, int age, int weight, int legs) {
    // 初始化父类部分
    Animal_Ctor(&this->parent, age, weight);
    // 初始化子类特有部分
    this->legs = legs;
}

// 转发父类方法
int Dog_GetAge(Dog *this) {
    return Animal_GetAge(&this->parent);
}

int Dog_GetLegs(Dog *this) {
    return this->legs;
}

3. 内存模型说明

由于 Dog 结构体的第一个成员是 Animal，在内存布局上，Dog 对象的前半部分就是 Animal 的数据。这使得我们可以通过强制类型转换或指针运算访问父类部分，从而实现继承效果。

五、多态：虚函数表模拟

多态依赖于运行时绑定。在 C++ 中通过虚表（vtable）实现，在 C 中我们需要手动维护虚表指针和虚函数表。

1. 父类增加虚表 (Animal.h)

#ifndef _ANIMAL_H_
#define _ANIMAL_H_

struct AnimalVTable; // 虚表前置声明

typedef struct {
    struct AnimalVTable *vptr; // 虚表指针
    int age;
    int weight;
} Animal;

// 虚表定义
typedef struct {
    void (*say)(Animal *this);
} AnimalVTable;

// 虚函数声明
void Animal_Say(Animal *this);

#endif

2. 父类实现 (Animal.c)

#include <assert.h>
#include "Animal.h"

// 默认虚函数实现（抽象）
static void _Animal_Say(Animal *this) {
    assert(0); // 类似纯虚函数，防止直接调用
}

// 构造函数
void Animal_Ctor(Animal *this, int age, int weight) {
    static struct AnimalVTable animal_vtbl = {_Animal_Say};
    this->vptr = &animal_vtbl;
    this->age = age;
    this->weight = weight;
}

// 多态调用入口
void Animal_Say(Animal *this) {
    if (this && this->vptr && this->vptr->say) {
        this->vptr->say(this);
    }
}

3. 子类重写虚表 (Dog.c)

#include "Dog.h"
#include <stdio.h>

static void _Dog_Say(Dog *this) {
    printf("dog says: woof!\n");
}

void Dog_Ctor(Dog *this, int age, int weight, int legs) {
    // 先初始化父类
    Animal_Ctor(&this->parent, age, weight);
    // 覆盖虚表指针指向子类虚表
    static struct AnimalVTable dog_vtbl = {_Dog_Say};
    this->parent.vptr = &dog_vtbl;
    this->legs = legs;
}

4. 测试多态

int main() {
    Dog d;
    Dog_Ctor(&d, 1, 3, 4);

    // 父类指针指向子类对象
    Animal *pa = &d.parent;

    // 调用时会根据 vptr 指向实际执行子类函数
    Animal_Say(pa);
    return 0;
}

六、实际应用案例

这种模式在底层系统中非常常见。

1. Linux 内核

Linux 网络协议栈大量使用了这种模式。例如 Socket 结构体：

struct sock { ... };
struct inet_sock { struct sock sk; ... };
struct udp_sock { struct sock sk; ... };

inet_sock 和 udp_sock 的第一个成员都是 sock，实现了逻辑上的继承关系，便于统一处理网络套接字。

2. GLib 库

GLib 字符串处理也遵循此模式：

GString *g_string_append(GString *string, const gchar *val);

所有操作都接受对象指针作为第一个参数，符合面向对象的方法调用习惯。

七、注意事项与局限性

尽管 C 语言可以模拟 OOP，但仍需注意以下限制：

1. 类型安全缺失：C 编译器不会检查 Animal* 是否真的指向 Animal 对象，容易引发段错误。
2. 内存管理：上述示例使用栈分配，若需动态生命周期，需结合 malloc/free 并在析构函数中释放资源。
3. 维护成本：缺乏编译期检查，重构难度大，需要严格的文档规范。
4. 性能开销：虚表指针间接调用比直接调用稍慢，但在嵌入式场景通常可接受。

八、总结

在 C 语言中实现面向对象编程，本质是利用结构体封装数据，利用函数指针实现多态。这种模式在嵌入式开发、操作系统内核及跨平台库设计中依然具有重要价值。熟练掌握这一技术，能帮助开发者更清晰地设计模块边界，提升代码的可维护性和扩展性。