C语言面向对象编程实战：用结构体与函数指针实现封装、继承与多态

尽管C语言常被视为一门面向过程的语言，但我们依然能够运用结构体和函数指针等机制，在C语言中模拟出面向对象编程的核心特性，即封装、继承和多态。这为编写模块化、可复用和可扩展的系统级代码提供了强大的思想工具。

封装：隐藏实现细节

封装旨在将数据（属性）和操作数据的方法（函数）捆绑为一个整体（对象），对外仅暴露必要的接口，从而隐藏内部实现细节。

在C语言中，结构体非常适合用来定义对象的属性集，而函数指针则可以指向对象的方法。将两者组合在一个结构体内，就构成了一个类的雏形。例如，我们可以定义一个表示Person的“类”：

#include <stdio.h>
#include <stdlib.h>

// 定义“人类”
struct person {
    // 属性
    char *name;
    int age;
    // 方法（函数指针）
    void (*say_hello)(struct person *p);
};

// 定义“人类”的方法实现
void say_hello(struct person *p) {
    printf("Hello, I am %s, %d years old.\n", p->name, p->age);
}

// “构造函数”：创建人类实例
struct person *create_person(char *name, int age) {
    struct person *p = malloc(sizeof(struct person));
    p->name = name;
    p->age = age;
    p->say_hello = say_hello; // 关联方法
    return p;
}

// 使用实例
int main() {
    struct person *p1 = create_person("Alice", 20);
    struct person *p2 = create_person("Bob", 25);
    p1->say_hello(p1);
    p2->say_hello(p2);
    free(p1);
    free(p2);
    return 0;
}

这里，struct person封装了name、age和say_hello方法。外部代码通过say_hello函数指针来调用行为，而无需关心其内部实现，这正是系统编程中模块化思想的基础。

继承：实现代码复用

继承允许子类复用父类的属性和方法，并可以添加或覆盖它们。

在C语言中，可以通过结构体嵌套来模拟继承：将父类结构体作为子类结构体的第一个成员。这确保了子类对象的内存布局起始部分与父类完全一致，从而可以通过强制类型转换将子类对象视为父类对象使用。

// 沿用之前定义的 person 结构体及相关函数...

// 定义“学生类”，继承自“人类”
struct student {
    // 将父类作为第一个成员，实现继承
    struct person base;
    // 子类新增属性
    char *school;
    // 子类新增方法
    void (*study)(struct student *s);
};

// 子类新增方法实现
void study(struct student *s) {
    printf("%s is studying at %s.\n", s->base.name, s->school);
}

// 学生类的“构造函数”
struct student *create_student(char *name, int age, char *school) {
    struct student *s = malloc(sizeof(struct student));
    // 初始化父类部分
    s->base.name = name;
    s->base.age = age;
    s->base.say_hello = say_hello; // 复用父类方法
    // 初始化子类部分
    s->school = school;
    s->study = study;
    return s;
}

int main() {
    struct student *s1 = create_student("Charlie", 18, "MIT");
    s1->base.say_hello(&s1->base); // 调用继承自父类的方法
    s1->study(s1); // 调用子类自己的方法
    free(s1);
    return 0;
}

这种通过结构体组合实现继承的方式，是许多底层系统软件和框架中常见的技巧。

多态：同一接口，不同行为

多态允许将不同类型的对象通过统一的接口进行操作，而实际执行的行为由对象的真实类型决定。

在C语言中，我们可以利用函数指针和“基类”指针来实现多态。不同类型的对象（子类）都将自己的特定方法赋值给基类结构体中的函数指针，当通过基类指针调用该函数时，就会执行子类的实现。

#include <stdio.h>
#include <stdlib.h>

// 定义“动物”基类
struct animal {
    char *name;
    void (*make_sound)(struct animal *a);
};

// 定义“狗”子类
struct dog {
    struct animal base; // 继承
    char *breed;
};

// 定义“猫”子类
struct cat {
    struct animal base; // 继承
    char *color;
};

// 基类的默认方法（可省略或作为兜底）
void animal_make_sound(struct animal *a) {
    printf("%s makes a sound.\n", a->name);
}

// 狗子类的具体方法
void dog_make_sound(struct animal *a) {
    struct dog *d = (struct dog *)a; // 将基类指针转换回子类指针
    printf("%s the dog barks: Woof! Woof!\n", d->base.name);
}

// 猫子类的具体方法
void cat_make_sound(struct animal *a) {
    struct cat *c = (struct cat *)a;
    printf("%s the cat meows: Meow~ Meow~\n", c->base.name);
}

// 创建狗实例
struct dog *create_dog(char *name, char *breed) {
    struct dog *d = malloc(sizeof(struct dog));
    d->base.name = name;
    d->base.make_sound = dog_make_sound; // 关键：指向子类实现
    d->breed = breed;
    return d;
}

// 创建猫实例
struct cat *create_cat(char *name, char *color) {
    struct cat *c = malloc(sizeof(struct cat));
    c->base.name = name;
    c->base.make_sound = cat_make_sound; // 关键：指向子类实现
    c->color = color;
    return c;
}

int main() {
    // 创建不同子类的对象，但用基类指针数组来管理
    struct animal *animals[2];
    animals[0] = (struct animal *)create_dog("Spike", "Bulldog");
    animals[1] = (struct animal *)create_cat("Jerry", "Brown");

    // 多态调用：同一接口，不同行为
    for (int i = 0; i < 2; i++) {
        animals[i]->make_sound(animals[i]);
    }

    // 释放内存（实际项目中需要更精细的管理）
    free(animals[0]);
    free(animals[1]);
    return 0;
}

在这个例子中，dog_make_sound和cat_make_sound函数都被赋值给了基类animal的make_sound指针。通过animal指针调用make_sound时，程序会自动执行对应子类的函数，实现了多态。这种模式在需要插件化架构或抽象接口的系统设计中尤为有用。

总结

通过结构体、函数指针和结构体嵌套，C语言能够有效地模拟面向对象编程的三大支柱。虽然语法上不如C++或Java等原生支持OOP的语言简洁，但这种模拟深刻揭示了面向对象特性的底层实现原理。掌握这些技巧，对于理解操作系统、嵌入式系统以及许多经典C语言库的内部设计大有裨益。