C语言面向对象编程实用指南：结构体与函数指针模拟三大特性

虽然C语言是一门经典的面向过程语言，但其灵活的特性允许开发者通过结构体和函数指针来模拟面向对象编程的核心思想，例如封装、继承和多态。这种方法在嵌入式系统开发以及一些追求高性能和可控性的底层系统（如Linux内核模块）中颇为常见。掌握这些技巧，能帮助你在C语言项目中构建出更模块化、更易维护的代码结构。

下面，我们通过具体的代码示例来探讨如何在C语言中实现面向对象的三大特性。

一、封装

封装旨在将数据（属性）和操作数据的方法（函数）绑定在一起，对外提供统一的接口，同时隐藏内部实现细节。

在C语言中，我们可以用结构体定义属性，用结构体内部的函数指针定义方法，从而模拟一个“类”。

示例：定义一个“Person”类

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

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

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

// “Person”类的构造函数
struct person *person_create(char *name, int age) {
    struct person *p = (struct person *)malloc(sizeof(struct person));
    p->name = name;
    p->age = age;
    p->say_hello = person_say_hello; // 将函数指针指向具体的实现
    return p;
}

// 使用“Person”类
int main() {
    struct person *alice = person_create("Alice", 20);
    struct person *bob = person_create("Bob", 25);

    alice->say_hello(alice);
    bob->say_hello(bob);

    free(alice);
    free(bob);
    return 0;
}

这个例子展示了如何将name、age属性和say_hello方法封装在struct person中，这是理解和运用C语言进行复杂程序设计的基础。

二、继承

继承允许子类复用父类的属性和方法，并可以扩展新的属性和方法，或重写父类方法。

在C语言中，可以通过结构体嵌套来实现继承：将父类结构体作为子类结构体的第一个成员。

示例：定义一个“Student”类继承自“Person”类

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

// 父类 Person（同上，略作调整）
struct person {
    char *name;
    int age;
    void (*say_hello)(struct person *p);
};

void person_say_hello(struct person *p) {
    printf("Hello, I am %s, %d years old.\n", p->name, p->age);
}

// 子类 Student
struct student {
    struct person base; // 继承：将父类作为第一个成员
    // 扩展属性
    char *school;
    // 扩展方法
    void (*study)(struct student *s);
};

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

// “Student”类的构造函数
struct student *student_create(char *name, int age, char *school) {
    struct student *s = (struct student *)malloc(sizeof(struct student));
    s->base.name = name;
    s->base.age = age;
    s->base.say_hello = person_say_hello; // 复用父类方法
    s->school = school;
    s->study = student_study; // 设置子类方法
    return s;
}

int main() {
    struct student *charlie = student_create("Charlie", 18, "MIT");
    struct student *david = student_create("David", 19, "Stanford");

    // 调用继承自父类的方法
    charlie->base.say_hello(&charlie->base);
    david->base.say_hello(&david->base);
    // 调用子类自己的方法
    charlie->study(charlie);
    david->study(david);

    free(charlie);
    free(david);
    return 0;
}

这种结构体嵌套的方式有效地模拟了单继承，是管理复杂数据结构关系的有效手段。

三、多态

多态允许不同类型的对象通过相同的接口调用，但实际执行的行为由对象的具体类型决定。

在C语言中，可以通过函数指针和类型转换来实现多态。通常，会定义一个包含通用函数指针的基类，子类在初始化时覆盖这个指针，指向自己特定的实现。

示例：定义“Animal”基类及其子类“Dog”和“Cat”

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

// 基类 Animal
struct animal {
    char *name;
    void (*make_sound)(struct animal *a); // 通用接口
};

// 子类 Dog
struct dog {
    struct animal base; // 继承
    char *breed;
};

// 子类 Cat
struct cat {
    struct animal base; // 继承
    char *color;
};

// 基类默认方法（可被覆盖）
void animal_make_sound(struct animal *a) {
    printf("%s makes a generic sound.\n", a->name);
}

// Dog类的方法实现
void dog_make_sound(struct animal *a) { // 注意参数类型需与基类函数指针匹配
    struct dog *d = (struct dog *)a; // 类型转换
    printf("%s the dog says: Woof! Woof!\n", d->base.name);
}

// Cat类的方法实现
void cat_make_sound(struct animal *a) {
    struct cat *c = (struct cat *)a;
    printf("%s the cat says: Meow~\n", c->base.name);
}

// 创建Dog对象
struct dog *dog_create(char *name, char *breed) {
    struct dog *d = (struct dog *)malloc(sizeof(struct dog));
    d->base.name = name;
    d->base.make_sound = dog_make_sound; // 关键：覆盖函数指针以实现多态
    d->breed = breed;
    return d;
}

// 创建Cat对象
struct cat *cat_create(char *name, char *color) {
    struct cat *c = (struct cat *)malloc(sizeof(struct cat));
    c->base.name = name;
    c->base.make_sound = cat_make_sound; // 覆盖函数指针
    c->color = color;
    return c;
}

int main() {
    // 创建不同类型的对象
    struct dog *spike = dog_create("Spike", "Bulldog");
    struct cat *jerry = cat_create("Jerry", "Brown");

    // 多态的体现：通过相同的基类接口调用，执行不同的行为
    struct animal *animals[] = { (struct animal *)spike, (struct animal *)jerry };
    for (int i = 0; i < 2; i++) {
        animals[i]->make_sound(animals[i]); // 统一的调用方式
    }

    free(spike);
    free(jerry);
    return 0;
}

通过函数指针的动态绑定，C语言可以实现运行时的多态行为，这对于设计可扩展的框架或驱动模型非常有用，尤其在资源受限的嵌入式系统中。

总结

利用结构体封装数据与函数指针，通过结构体嵌套实现继承，再借助函数指针的动态绑定来表现多态，这些方法构成了在C语言中进行面向对象风格编程的核心。虽然不如C++、Java等原生支持OOP的语言那样方便，但这种模式在Linux内核、许多开源库以及嵌入式开发中得到了广泛验证，能够显著提升大型C项目的组织性和可维护性。