📚 课程目录第2章嵌入式C语言基础回顾

嵌入式C语言基础回顾：指针、结构体、函数指针、内存管理、位操作及其在OOP中的应用

面向对象编程（OOP）的核心思想是“将数据与操作数据的方法绑定在一起，并通过抽象、封装、继承和多态来组织代码”。然而，在嵌入式C语言环境中，我们并没有语言原生的 class、namespace 或 virtual 关键字。幸运的是，C语言提供的指针、结构体、函数指针、内存管理和位操作等基础语法，恰好构成了实现OOP四大特性的“积木”。本章将系统回顾这些关键知识点，并深入剖析它们如何被巧妙地映射到OOP的设计与实现中，为后续学习具体的设计模式打下坚实的语法与思维基础。

上图清晰地展示了本章的核心逻辑：C语言的基础语法并非孤立存在，它们分别对应着OOP中的某一项或多项能力。例如，结构体是“封装”的物理载体，函数指针是“多态”与“抽象”的语法基础，而指针则是实现“继承”和对象动态管理的核心工具。接下来，我们将逐一深入这些知识点，并探讨其在嵌入式OOP中的具体应用手法。

2.1 指针：对象的“身份证”与“操作手柄”

核心原理：数据访问的间接层

指针的本质是保存另一个变量内存地址的变量。在嵌入式系统中，指针不仅是访问硬件寄存器（如 *(volatile uint32_t *)0x40021000）的必备手段，更是实现OOP中“对象引用”的关键。在C语言中，我们无法直接传递“对象”，但可以传递指向对象（即结构体变量）的指针。通过指针，函数可以修改结构体内部的数据，而无需进行耗时的整体拷贝，这在资源受限的MCU上尤为重要。

操作流程：指针使用的“三必须”原则

必须初始化：声明指针后立即赋予其合法的地址（如 &my_obj 或 malloc 的返回值），避免“野指针”。
必须判空：在解引用指针前，检查是否为 NULL，防止非法访问导致HardFault。
必须配对释放：如果指针指向堆内存，使用完毕后必须 free，并置为 NULL，防止内存泄漏和悬垂指针。

案例拆解：对象指针作为函数参数

考虑一个LED驱动模块。我们定义一个结构体 LED_t 表示一个LED对象，包含端口、引脚和状态。通过传递指针，我们可以编写一个通用的控制函数：

typedef struct {
    GPIO_TypeDef *port;
    uint16_t pin;
    uint8_t state;
} LED_t;

void LED_SetState(LED_t *led, uint8_t new_state) {
    if (led == NULL) return;
    led->state = new_state;
    if (new_state) {
        HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_SET);
    } else {
        HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_RESET);
    }
}

这里，LED_t *led 就是对象的“操作手柄”。函数内部通过指针直接操作结构体成员，实现了对LED硬件资源的封装。这种模式是后续所有OOP设计的基础。

常见误区：在嵌入式开发中，滥用指针进行强制类型转换（如将 uint32_t 地址强转为结构体指针）可能导致数据对齐问题（Alignment Fault）。务必确保指针指向的地址满足结构体对齐要求（通常为4字节对齐）。

2.2 结构体：数据封装的“容器”

核心原理：将相关数据聚合为一个新类型

结构体是C语言实现“类”的物理基础。它将一组相关的变量（成员）聚合为一个整体，从而在逻辑上形成一个“对象”。在OOP中，类的属性（成员变量）直接对应结构体的成员。通过将操作这些属性的函数（通过函数指针）也放入结构体，我们就得到了一个“类”的雏形。

判断方法：何时使用结构体？

当多个数据项在逻辑上属于同一个实体（如一个传感器的校准值、状态标志、原始数据），并且需要被多个函数共享或传递时，就应该将它们封装为一个结构体。这有助于提高代码的可读性和可维护性。

案例拆解：结构体实现“类”的封装

我们扩展LED的例子，将函数指针也放入结构体，使其更接近C++的类：

typedef struct LED_Ops LED_Ops_t;
typedef struct LED {
    GPIO_TypeDef *port;
    uint16_t pin;
    uint8_t state;
    const LED_Ops_t *ops; // 指向操作函数集的指针
} LED_t;

struct LED_Ops {
    void (*init)(LED_t *self);
    void (*set_state)(LED_t *self, uint8_t state);
    uint8_t (*get_state)(LED_t *self);
};

// 具体实现函数
static void led_init(LED_t *self) { /* 初始化GPIO */ }
static void led_set_state(LED_t *self, uint8_t state) { /* 设置状态 */ }
static uint8_t led_get_state(LED_t *self) { return self->state; }

// 操作函数集实例（相当于vtable）
const LED_Ops_t led_ops = {
    .init = led_init,
    .set_state = led_set_state,
    .get_state = led_get_state
};

// 实例化一个LED对象
LED_t led1 = { .port = GPIOA, .pin = GPIO_PIN_5, .state = 0, .ops = &led_ops };

在这个例子中，LED_t 结构体不仅包含了数据（属性），还通过 ops 指针关联了操作函数（方法）。这就是C语言实现“封装”和“抽象”的经典手法。

OOP概念	C语言实现方式	本例对应
类 (Class)	结构体定义 + 操作函数集	`LED_t` + `LED_Ops_t`
对象 (Object)	结构体变量	`led1`
方法 (Method)	函数指针成员	`ops->set_state`
封装 (Encapsulation)	将数据和函数绑定在结构体内	通过 `ops` 调用函数

经验提醒：在嵌入式系统中，应谨慎使用柔性数组成员（Flexible Array Member）作为结构体最后一个成员，虽然它能实现变长数据，但会破坏结构体的可拷贝性，并增加内存管理的复杂度。建议使用固定大小的数组或指针。

2.3 函数指针：实现多态与回调的“灵魂”

核心原理：将函数作为变量传递

函数指针保存的是函数的入口地址。它允许我们在运行时决定调用哪个函数，这是实现OOP中“多态”和“策略模式”的基石。在嵌入式领域，函数指针广泛应用于中断回调、状态机跳转、设备驱动抽象等场景。

操作流程：定义、赋值与调用

定义：返回类型 (*指针名)(参数列表)，例如 void (*handler)(int event);
赋值：handler = &my_event_handler; 或直接 handler = my_event_handler;（函数名即地址）。
调用：handler(1); 或 (*handler)(1); 两种写法等价。

案例拆解：用函数指针实现设备抽象（多态）

假设系统需要支持两种温度传感器：I2C接口的SHT30和SPI接口的MAX31865。我们可以定义一个通用的传感器操作接口：

typedef struct {
    int (*init)(void);
    float (*read_temp)(void);
} Sensor_Ops_t;

// SHT30驱动
static int sht30_init(void) { /* 初始化I2C */ }
static float sht30_read_temp(void) { /* 读取温度 */ }
const Sensor_Ops_t sht30_ops = { sht30_init, sht30_read_temp };

// MAX31865驱动
static int max31865_init(void) { /* 初始化SPI */ }
static float max31865_read_temp(void) { /* 读取温度 */ }
const Sensor_Ops_t max31865_ops = { max31865_init, max31865_read_temp };

// 应用层代码
const Sensor_Ops_t *active_sensor;
void app_init(void) {
    if (hardware_version == V1) {
        active_sensor = &sht30_ops;
    } else {
        active_sensor = &max31865_ops;
    }
    active_sensor->init();
}
float app_get_temperature(void) {
    return active_sensor->read_temp();
}

这里，active_sensor 指针指向不同的操作集，从而在运行时表现出不同的行为，这正是“多态”的体现。上层代码完全不需要关心底层是I2C还是SPI，极大地降低了模块间的耦合度。

常见误区：函数指针的类型必须严格匹配，包括返回类型和参数类型。如果使用 void* 作为参数来“绕过”类型检查，会破坏类型安全，极易引发难以排查的运行时错误。建议为不同的函数签名定义不同的函数指针类型。

2.4 内存管理：对象的“生命周期”管理

核心原理：静态分配与动态分配的选择

嵌入式系统的内存极其有限。OOP中的“对象”需要占用内存，其生命周期（创建、使用、销毁）必须被严格管理。C语言提供 malloc/free 进行动态内存分配，但在MCU上使用它们需要格外小心，因为可能产生内存碎片。

判断方法：何时使用动态内存？

优先使用静态分配：在编译时确定对象数量和大小，使用全局或静态数组。这避免了运行时分配的开销和碎片问题，是嵌入式OOP的首选。
谨慎使用动态分配：仅在对象数量无法预知（如通信协议中的可变长包）或需要节省静态RAM时使用。必须实现内存池或使用RTOS提供的堆管理。

案例拆解：对象池管理固定数量的对象

为了避免动态内存碎片，我们可以为特定类型的对象建立“对象池”。例如，一个网络协议栈需要管理多个连接控制块（PCB）：

#define MAX_PCB_NUM 4
static PCB_t pcb_pool[MAX_PCB_NUM];
static uint8_t pcb_used[MAX_PCB_NUM]; // 0: 空闲, 1: 占用

PCB_t* pcb_alloc(void) {
    for (int i = 0; i < MAX_PCB_NUM; i++) {
        if (!pcb_used[i]) {
            pcb_used[i] = 1;
            return &pcb_pool[i];
        }
    }
    return NULL; // 池已满
}
void pcb_free(PCB_t *pcb) {
    if (pcb != NULL) {
        // 计算索引
        int index = pcb - pcb_pool;
        if (index >= 0 && index < MAX_PCB_NUM) {
            pcb_used[index] = 0;
            memset(pcb, 0, sizeof(PCB_t)); // 清空数据
        }
    }
}

这种“对象池”模式是嵌入式OOP中管理有限资源的经典手法，它避免了 malloc 的不确定性，保证了实时性。

经验提醒：在C语言中实现OOP时，建议在结构体定义中增加一个 magic 字段（如 0xDEADBEEF），在函数入口处校验该字段，以检测内存越界或悬垂指针访问，这是嵌入式软件防御性编程的重要手段。

2.5 位操作：高效利用资源的“魔法”

核心原理：直接操作二进制位

位操作（&、|、^、~、<<、>>）是嵌入式C语言的特色。在OOP中，它常用于实现“标志位”或“位域”，以极小的内存代价存储多个布尔状态，或者用于操作硬件寄存器中的特定控制位。

操作流程：置位、清零与翻转

置位：reg |= (1 << n);
清零：reg &= ~(1 << n);
翻转：reg ^= (1 << n);
读取：bit = (reg >> n) & 0x01;

案例拆解：用位域定义对象的状态

假设一个任务控制块（TCB）需要保存多个状态：是否就绪、是否等待事件、是否超时。使用位域可以节省RAM：

typedef struct {
    uint8_t ready : 1;
    uint8_t waiting : 1;
    uint8_t timeout : 1;
    uint8_t priority : 3; // 0-7
    uint8_t reserved : 2;
} Task_Status_t;

// 使用方式
Task_Status_t status;
status.ready = 1;
status.priority = 5;
if (status.timeout) { /* 处理超时 */ }

位域在内存中紧凑排列，非常适合资源受限的场景。但需要注意，位域的布局（如字节序、对齐）是编译器相关的，在跨平台或跨编译器开发时需谨慎。

操作类型	运算符	典型应用场景
置位	`\|`	设置GPIO输出高电平、使能中断
清零	`&` + `~`	清除状态标志、关闭外设
翻转	`^`	切换LED状态、反转时钟极性
移位	`<<` / `>>`	提取寄存器中的字段值、快速乘除2的幂

常见误区：位域虽然节省空间，但访问速度可能比直接访问整型变量慢，因为编译器需要额外的掩码和移位操作。在性能敏感的代码路径（如中断处理函数）中，建议使用整型变量配合宏定义来操作位，而不是位域。

2.6 综合实战：构建一个可复用的“定时器”对象

为了将上述知识点融会贯通，我们设计一个简单的软件定时器对象。该对象具备启动、停止、查询超时状态的功能，并支持回调函数。

需求与约束

MCU：STM32F103，RAM 20KB。
需要管理8个软件定时器。
定时精度要求不高（毫秒级），但要求不能阻塞CPU。
定时器超时后，自动调用用户注册的回调函数。

设计实现

#define MAX_TIMERS 8
typedef void (*timeout_cb_t)(void *arg);

typedef struct {
    uint32_t timeout_ms;
    uint32_t start_tick;
    uint8_t active;
    timeout_cb_t cb;
    void *cb_arg;
} SoftTimer_t;

static SoftTimer_t timers[MAX_TIMERS];

void Timer_Init(void) {
    memset(timers, 0, sizeof(timers));
}

int Timer_Start(uint8_t id, uint32_t timeout_ms, timeout_cb_t cb, void *arg) {
    if (id >= MAX_TIMERS) return -1;
    if (timers[id].active) return -2; // 定时器正在运行
    timers[id].timeout_ms = timeout_ms;
    timers[id].start_tick = HAL_GetTick();
    timers[id].active = 1;
    timers[id].cb = cb;
    timers[id].cb_arg = arg;
    return 0;
}

void Timer_Stop(uint8_t id) {
    if (id < MAX_TIMERS) {
        timers[id].active = 0;
    }
}

void Timer_Poll(void) {
    uint32_t now = HAL_GetTick();
    for (int i = 0; i < MAX_TIMERS; i++) {
        if (timers[i].active) {
            if ((now - timers[i].start_tick) >= timers[i].timeout_ms) {
                timers[i].active = 0;
                if (timers[i].cb) {
                    timers[i].cb(timers[i].cb_arg);
                }
            }
        }
    }
}

分析与复盘

封装：SoftTimer_t 结构体封装了定时器的所有属性和行为（通过函数指针 cb）。
内存管理：使用静态数组 timers[MAX_TIMERS] 作为对象池，避免了动态内存分配。
指针应用：cb 和 cb_arg 实现了回调机制，允许用户代码与定时器模块解耦。
位操作：虽然本例未直接使用位操作，但在实际系统中，active 标志可以扩展为位域以节省内存。

这个案例展示了如何利用C语言的基础语法，构建一个具备OOP特性的、可复用的软件组件。它遵循了“高内聚、低耦合”的设计原则，为后续引入更复杂的设计模式（如观察者模式、状态模式）提供了范例。

总结复盘：本章回顾的五个关键知识点是嵌入式C语言OOP的基石。指针提供了对象的引用方式，结构体提供了封装载体，函数指针实现了多态与回调，内存管理决定了对象的生命周期策略，位操作则优化了资源利用。掌握这些基础，并理解它们与OOP特性的映射关系，是后续学习设计模式的前提。在实际编码中，务必牢记“防御性编程”原则，对指针进行判空、对数组进行边界检查，并谨慎使用动态内存。