3、面向对象编程核心概念：封装、继承、多态在C语言中的映射与实现思路

面向对象编程（OOP）的三大核心概念——封装、继承、多态——在嵌入式C语言开发中并非“能不能用”的问题，而是“如何用得更工程化”的问题。C语言虽非面向对象语言，但其结构体、函数指针、宏定义等机制，足以支撑起一套轻量级、可维护的OOP实现范式。本章将深入剖析这三个概念在C语言中的底层映射关系，并给出可直接落地的实现思路与代码骨架。

3.1 封装：结构体与不透明指针的工程实践

核心原理

封装的本质是“信息隐藏”与“接口与实现分离”。在C语言中，结构体天然具备数据聚合能力，而函数指针则可以将行为绑定到数据上。更关键的是，通过头文件与源文件的分离，可以在头文件中只暴露操作函数原型，而将结构体定义隐藏在源文件中，形成真正的“不透明类型”。

// device.h —— 对外接口
typedef struct Device Device;  // 不透明类型声明

Device* device_create(int type);
void    device_destroy(Device* dev);
int     device_read(Device* dev, uint8_t* buf, uint32_t len);
int     device_write(Device* dev, const uint8_t* data, uint32_t len);

// device.c —— 内部实现
struct Device {
    int      type;
    uint8_t  addr;
    void*    priv;      // 指向具体硬件寄存器或私有数据
    int      (*read)(Device*, uint8_t*, uint32_t);
    int      (*write)(Device*, const uint8_t*, uint32_t);
};

判断方法

• 数据是否被外部直接修改？ 若结构体成员被外部直接赋值，则封装被破坏。
• 是否可以通过接口完成所有操作？ 若外部代码需要访问结构体内部字段才能完成功能，说明接口设计不完整。
• 更换底层实现是否影响上层代码？ 若修改内部实现后，调用方代码无需改动，则封装良好。

案例拆解：传感器驱动封装

假设需要驱动三款不同的温度传感器（DS18B20、SHT30、NTC热敏电阻），它们的数据读取方式完全不同。通过封装，我们可以为上层提供统一的 temp_sensor_read() 接口，而内部根据传感器类型调用不同的底层函数。

封装后的调用方式：

TempSensor* sensor = temp_sensor_create(TYPE_SHT30, I2C_BUS1, 0x44);
float temp = temp_sensor_read_celsius(sensor);
temp_sensor_destroy(sensor);

上层代码完全不需要知道SHT30的I2C时序、命令字、校验算法等细节。当需要更换传感器型号时，只需修改创建函数中的类型参数，其余代码零改动。

3.2 继承：结构体嵌套与类型强转

核心原理

C语言没有继承关键字，但通过“结构体嵌套”可以模拟单继承关系。派生结构体的第一个成员放置基类结构体，这样派生类指针与基类指针的地址完全一致，可以安全地进行类型强转。这种设计在嵌入式驱动分层中极为常见。

// 基类：通用设备
typedef struct {
    uint8_t  id;
    uint8_t  bus_type;
    void*    reg_base;
} BaseDevice;

// 派生类：I2C设备
typedef struct {
    BaseDevice base;      // 必须放在第一位
    uint8_t    i2c_addr;
    uint32_t   clk_rate;
} I2CDevice;

// 派生类：SPI设备
typedef struct {
    BaseDevice base;
    uint8_t    cs_pin;
    uint8_t    mode;
} SPIDevice;

操作流程

1. 定义基类结构体，包含所有派生类共有的属性。
2. 定义派生类结构体，首成员为基类类型。
3. 类型转换：BaseDevice* base = (BaseDevice*)i2c_dev; 即可将派生类指针当作基类指针使用。
4. 反向转换：I2CDevice* i2c = (I2CDevice*)base; 前提是确认该基类指针确实指向I2CDevice。

案例拆解：设备管理器

一个典型的嵌入式系统可能同时挂载多个I2C传感器、SPI Flash、UART外设。设备管理器需要统一管理这些设备的注册、初始化、状态查询。通过继承机制，可以构建一个设备链表：

typedef struct DeviceNode {
    BaseDevice* dev;
    struct DeviceNode* next;
} DeviceNode;

// 注册设备
void device_register(BaseDevice* dev) {
    // 将dev挂入链表
}

// 遍历所有设备，执行初始化
void device_init_all(void) {
    DeviceNode* node = head;
    while (node) {
        if (node->dev->init) {
            node->dev->init(node->dev);
        }
        node = node->next;
    }
}

这里 BaseDevice 中还可以加入函数指针 init、deinit、get_status 等，形成“抽象基类 + 具体派生”的经典模式。

3.3 多态：函数指针表与运行时绑定

核心原理

多态的核心是“同一接口，不同实现”。在C语言中，最优雅的实现方式是函数指针表（vtable）。每个“类”维护一个静态的函数指针数组，实例中保存指向该表的指针。调用时通过实例找到表，再通过表找到具体函数。

// 接口定义
typedef struct {
    int (*open)(void* self);
    int (*close)(void* self);
    int (*read)(void* self, uint8_t* buf, uint32_t len);
    int (*write)(void* self, const uint8_t* data, uint32_t len);
} FileOps;

// 具体实现：UART文件
static int uart_open(void* self) { /* ... */ }
static int uart_read(void* self, uint8_t* buf, uint32_t len) { /* ... */ }

static const FileOps uart_ops = {
    .open  = uart_open,
    .close = uart_close,
    .read  = uart_read,
    .write = uart_write,
};

// 实例结构体
typedef struct {
    const FileOps* ops;
    UART_HandleTypeDef* huart;
} UARTFile;

判断方法

• 是否存在“一组相似操作，但实现不同”？ 例如多个设备都有read/write，但实现逻辑完全不同。
• 是否需要在运行时决定调用哪个实现？ 例如根据配置文件选择使用Flash还是SD卡存储日志。
• 是否希望新增设备类型时，不修改上层调用代码？ 这是多态最大的价值。

案例拆解：日志系统抽象

假设系统需要支持三种日志输出目标：UART、Flash文件系统、RAM环形缓冲区。通过多态设计，日志模块只需面向 LogSink 接口编程：

typedef struct {
    void (*log_write)(void* ctx, const char* msg, uint32_t len);
    void (*log_flush)(void* ctx);
} LogSink;

// 上层日志模块
void log_message(LogSink* sink, const char* msg) {
    sink->log_write(sink->ctx, msg, strlen(msg));
    if (need_flush) {
        sink->log_flush(sink->ctx);
    }
}

当需要新增“网络日志”时，只需实现 LogSink 接口并传入即可，日志模块代码完全不需要修改。这种模式在嵌入式系统中广泛应用于协议栈、文件系统、设备驱动等场景。

3.4 三大概念的协同应用与设计权衡

核心原理

封装、继承、多态并非孤立存在。在实际嵌入式项目中，三者往往协同工作：封装保证模块边界清晰，继承实现代码复用，多态提供运行时灵活性。一个典型的组合是：封装基类数据 + 继承扩展属性 + 多态绑定行为。

操作流程

1. 识别稳定接口：分析系统中哪些操作是稳定的（如open/read/write/close），将其抽象为接口。
2. 设计基类结构体：包含所有实现共有的数据字段和函数指针表。
3. 派生具体类：通过结构体嵌套继承基类，添加特有字段，实现接口函数。
4. 工厂函数创建实例：根据参数返回基类指针，上层只与基类交互。

案例拆解：通用GPIO驱动框架

一个完整的GPIO驱动框架可以完美展示三者协同：

// 基类：GPIO设备
typedef struct {
    void (*set)(void* self, uint8_t level);
    uint8_t (*get)(void* self);
    void (*toggle)(void* self);
} GpioOps;

typedef struct {
    const GpioOps* ops;
    uint8_t port;
    uint8_t pin;
} GpioDevice;

// 派生：MCU内部GPIO
typedef struct {
    GpioDevice base;
    GPIO_TypeDef* gpio_reg;
} McuGpio;

// 派生：I2C扩展GPIO (如PCF8575)
typedef struct {
    GpioDevice base;
    I2C_HandleTypeDef* hi2c;
    uint8_t dev_addr;
} I2cGpio;

// 工厂函数
GpioDevice* gpio_create(GpioType type, void* config) {
    if (type == GPIO_MCU) {
        McuGpio* dev = malloc(sizeof(McuGpio));
        dev->base.ops = &mcu_gpio_ops;
        // 初始化...
        return &dev->base;
    } else if (type == GPIO_I2C) {
        I2cGpio* dev = malloc(sizeof(I2cGpio));
        dev->base.ops = &i2c_gpio_ops;
        // 初始化...
        return &dev->base;
    }
    return NULL;
}

上层代码只需调用 gpio_set(dev, 1) 即可，完全不需要关心底层是MCU引脚还是I2C扩展芯片。当系统需要增加SPI扩展GPIO时，只需新增一个派生类和对应的ops表。

总结复盘

封装、继承、多态在C语言中的实现，本质上是利用结构体、指针和函数指针，在“代码复用”和“运行效率”之间寻找平衡。嵌入式开发者应掌握以下核心认知：

• 封装是基础：没有封装，后续的继承和多态都无从谈起。先确保模块边界清晰。
• 继承是手段：通过结构体嵌套实现代码复用，但不要为了继承而继承，组合有时更优。
• 多态是升华：当系统存在多个相似实现且需要统一管理时，多态能极大提升可维护性。
• 性能意识：每次抽象都伴随代价，在资源受限的MCU上，需要量化评估开销。

在实际项目中，建议从“最小可用”开始：先用简单的结构体+函数实现功能，当出现第二个相似实现时，再考虑引入继承和多态。过早的抽象和过度的设计，在嵌入式领域往往比“代码重复”更危险。