代码重构：用设计模式优化 legacy C代码

作为嵌入式DSP C开发者，你大概率深陷过legacy（遗留）代码的“泥潭”：接手的硬件驱动代码杂乱无章，函数嵌套层层嵌套、冗余代码随处可见，不同传感器的驱动逻辑混堆在一起，新增一个驱动要复制粘贴几百行重复代码，改一个bug牵一发而动全身，调试时找一段核心逻辑要翻遍整个文件，后续维护成本高到让人崩溃。很多同行秉持“能跑就行”的心态，但legacy代码就像一颗定时炸弹，随着项目迭代只会越来越难维护，甚至直接影响产品稳定性。今天就手把手教你，用“工厂模式+策略模式”落地legacy硬件驱动代码优化，从重构步骤、工程化分析，到C语言实操实现、实战验证调试，全程聚焦嵌入式实操，帮你彻底摆脱legacy代码的困扰，写出高可维护、高可扩展、易调试的嵌入式C代码。

一、原理拆解：重构与设计模式核心认知

动手重构前，我们先理清两个核心概念，避免走入“为了重构而重构”“为了用设计模式而用设计模式”的误区——对嵌入式开发者而言，一切技术都要服务于工程实战，重构和设计模式也不例外，实用、适配才是核心。

1.1 代码重构的核心目标

代码重构绝非重写代码，核心是在不改变代码原有功能的前提下，优化代码结构、消除冗余、提升可读性和可维护性，降低后续迭代和bug修复的成本。对于嵌入式DSP C开发，重构还有一个关键约束：不能增加过多运算量和内存占用，必须适配MCU/DSP的硬件资源限制，这也是我们选型简单实用设计模式的核心原因。

结合legacy硬件驱动代码的常见痛点，本次重构的具体目标明确：消除驱动代码冗余、分离不同硬件的驱动逻辑、定义统一调用接口，实现“新增驱动不修改原有代码、修改一个驱动不影响其他模块”，同时保证代码运行效率不下降，贴合嵌入式硬件实操需求。

1.2 适配C语言的设计模式选型

很多开发者误以为设计模式是C++、Java等面向对象语言的专属，C语言无法应用——其实不然，设计模式的核心是“解决问题的思路”，而非特定语法。针对legacy硬件驱动代码“多设备、多逻辑、高冗余”的痛点，我们选型“工厂模式+策略模式”的组合，二者优势互补，完全适配C语言语法特性，运算量小、易落地、无额外资源负担：

组合优势：工厂模式负责“创建驱动实例”，策略模式负责“实现驱动逻辑”，二者分离后，新增硬件驱动时，只需新增一个策略实现和工厂注册，无需修改原有业务代码和其他驱动逻辑，完美契合“开放-封闭原则”，大幅降低后续维护成本。

二、工程化分析：重构步骤与legacy代码痛点拆解

本次实战案例以嵌入式开发中最常见的“多传感器驱动代码”为核心（典型legacy场景），假设我们接手了一段legacy代码：包含MPU6050、BMI088、ADXL345三种加速度传感器的驱动，所有代码全部写在一个文件中，无统一接口、冗余严重、逻辑混乱。我们先拆解其核心痛点，再明确标准化的重构步骤，确保每一步都可落地、无冗余。

2.1 legacy驱动代码核心痛点（真实场景复刻）

这段legacy代码的典型问题，也是很多嵌入式开发者常写的“坏代码”，具体痛点如下，看看你是否遇到过：

2.2 标准化重构步骤（嵌入式实战可直接复用）

结合嵌入式开发“注重稳定性、硬件资源受限”的特性，我们制定“四步走”重构步骤，每一步都有明确的目标和可落地的操作，确保重构过程安全、高效，避免出现功能异常，嵌入式开发者可直接复用：

三、C语言实现：工厂模式+策略模式重构实战

以下基于上述重构步骤，以“MPU6050、BMI088、ADXL345三种传感器驱动”为例，完整实现代码重构，代码严格适配DSP C开发规范，简洁高效、可直接复制移植，每一步都添加详细注释，便于新手理解和修改，贴合嵌入式实操需求。

3.1 第一步：定义统一接口与数据结构（核心基础）

先封装统一的驱动接口和传感器数据结构，这是实现设计模式、消除冗余的核心基础，所有传感器驱动都将遵循这个规范，确保接口统一、逻辑清晰，后续新增驱动也能快速适配。

#include "stdio.h"
#include "stdint.h"
#include "i2c.h" // 假设已实现I2C底层驱动（嵌入式实战中需替换为自身底层）

// 传感器类型枚举（新增传感器时，只需新增枚举值，无需修改其他代码）
typedef enum {
SENSOR_MPU6050, // MPU6050加速度传感器
SENSOR_BMI088, // BMI088加速度传感器
SENSOR_ADXL345, // ADXL345加速度传感器
SENSOR_MAX // 传感器类型最大值（用于边界判断，避免越界）
} SensorType;

// 传感器数据结构体（通用属性，所有传感器共用，统一管理）
typedef struct {
SensorType type; // 传感器类型（标记当前驱动对应的传感器）
uint8_t i2c_addr; // 传感器I2C地址
uint16_t sample_rate; // 传感器采样频率（Hz）
int16_t accel_data[3]; // 加速度数据缓存（x,y,z轴，统一存储格式）
} SensorDev;

// 驱动策略接口（统一接口，所有传感器驱动必须实现，屏蔽差异化）
// 对应策略模式的"策略抽象"，封装所有驱动的通用操作
typedef struct {
// 初始化传感器（所有传感器统一接口，参数一致）
uint8_t (*init)(SensorDev *dev, uint16_t sample_rate);
// 读取加速度数据（统一接口，数据输出格式一致）
uint8_t (*read_accel)(SensorDev *dev, int16_t *accel_data);
// 写入寄存器配置（统一接口，适配所有传感器寄存器操作）
uint8_t (*write_reg)(SensorDev *dev, uint8_t reg_addr, uint8_t data);
// 关闭传感器（低功耗场景可用，统一接口）
void (*deinit)(SensorDev *dev);
} SensorStrategy;

// 传感器工厂结构体（管理所有传感器策略，对应工厂模式核心）
typedef struct {
SensorStrategy strategies[SENSOR_MAX]; // 策略数组，存储所有传感器的驱动实现
} SensorFactory;

// 全局工厂实例（供外部调用，统一创建驱动，无需重复定义）
static SensorFactory sensor_factory;
// 全局传感器实例（可根据需求改为动态分配，适配多传感器同时使用场景）
static SensorDev sensor_dev;

3.2 第二步：实现差异化驱动策略（策略模式核心）

将每种传感器的差异化驱动逻辑，封装为独立的策略实现（对应策略模式的“具体策略”），每种策略都严格实现统一的接口，仅差异化实现自身的寄存器配置、数据转换等逻辑。这里仅展示核心逻辑（初始化、数据读取），实战中可根据传感器 datasheet 补充完整配置。

/************************** MPU6050 驱动策略实现 **************************/
// MPU6050初始化（具体策略实现，严格遵循统一接口）
static uint8_t mpu6050_init(SensorDev *dev, uint16_t sample_rate) {
dev->i2c_addr = 0x68; // MPU6050默认I2C地址（差异化参数）
dev->sample_rate = sample_rate;

// 初始化MPU6050（配置电源管理、采样频率，具体寄存器参考 datasheet）
I2C_WriteByte(dev->i2c_addr, 0x6B, 0x00); // 唤醒MPU6050（差异化配置）
I2C_WriteByte(dev->i2c_addr, 0x19, (1000/sample_rate) – 1); // 配置采样频率

printf("MPU6050 init success, sample rate: %d Hz\\r\\n", sample_rate);
return 0; // 0表示成功，非0表示失败（统一返回值规范）
}

// MPU6050读取加速度数据（具体策略实现，严格遵循统一接口）
static uint8_t mpu6050_read_accel(SensorDev *dev, int16_t *accel_data) {
uint8_t data[6];
// 读取加速度数据寄存器（0x3B~0x40，MPU6050差异化寄存器地址）
I2C_ReadBytes(dev->i2c_addr, 0x3B, 6, data);

// 转换数据（根据MPU6050精度，差异化换算逻辑，参考 datasheet）
accel_data[0] = (data[0] << 8) | data[1];
accel_data[1] = (data[2] << 8) | data[3];
accel_data[2] = (data[4] << 8) | data[5];

// 保存到传感器实例中，统一数据缓存格式
dev->accel_data[0] = accel_data[0];
dev->accel_data[1] = accel_data[1];
dev->accel_data[2] = accel_data[2];

return 0;
}

// MPU6050写入寄存器（具体策略实现，统一接口）
static uint8_t mpu6050_write_reg(SensorDev *dev, uint8_t reg_addr, uint8_t data) {
return I2C_WriteByte(dev->i2c_addr, reg_addr, data);
}

// MPU6050关闭（具体策略实现，统一接口）
static void mpu6050_deinit(SensorDev *dev) {
I2C_WriteByte(dev->i2c_addr, 0x6B, 0x07); // 进入睡眠模式（差异化配置）
printf("MPU6050 deinit success\\r\\n");
}

// MPU6050策略实例（绑定具体实现，供工厂注册使用）
static SensorStrategy mpu6050_strategy = {
.init = mpu6050_init,
.read_accel = mpu6050_read_accel,
.write_reg = mpu6050_write_reg,
.deinit = mpu6050_deinit
};

/************************** BMI088 驱动策略实现 **************************/
// BMI088初始化（具体策略实现，严格遵循统一接口）
static uint8_t bmi088_init(SensorDev *dev, uint16_t sample_rate) {
dev->i2c_addr = 0x18; // BMI088默认I2C地址（差异化参数）
dev->sample_rate = sample_rate;

// BMI088初始化（配置电源、采样频率，具体寄存器参考 datasheet）
I2C_WriteByte(dev->i2c_addr, 0x7E, 0x04); // 唤醒BMI088（差异化配置）
I2C_WriteByte(dev->i2c_addr, 0x40, (sample_rate <= 1000) ? 0x08 : 0x0A);

printf("BMI088 init success, sample rate: %d Hz\\r\\n", sample_rate);
return 0;
}

// BMI088读取加速度数据（具体策略实现，严格遵循统一接口）
static uint8_t bmi088_read_accel(SensorDev *dev, int16_t *accel_data) {
uint8_t data[6];
I2C_ReadBytes(dev->i2c_addr, 0x12, 6, data); // BMI088差异化寄存器地址

// BMI088数据转换（精度不同，差异化换算逻辑，参考 datasheet）
accel_data[0] = (data[1] << 8) | data[0];
accel_data[1] = (data[3] << 8) | data[2];
accel_data[2] = (data[5] << 8) | data[4];

dev->accel_data[0] = accel_data[0];
dev->accel_data[1] = accel_data[1];
dev->accel_data[2] = accel_data[2];

return 0;
}

// BMI088其他接口实现（省略，与MPU6050逻辑类似，遵循统一接口）
static uint8_t bmi088_write_reg(SensorDev *dev, uint8_t reg_addr, uint8_t data) {
return I2C_WriteByte(dev->i2c_addr, reg_addr, data);
}

static void bmi088_deinit(SensorDev *dev) {
I2C_WriteByte(dev->i2c_addr, 0x7E, 0x00); // 睡眠模式（差异化配置）
printf("BMI088 deinit success\\r\\n");
}

static SensorStrategy bmi088_strategy = {
.init = bmi088_init,
.read_accel = bmi088_read_accel,
.write_reg = bmi088_write_reg,
.deinit = bmi088_deinit
};

/************************** ADXL345 驱动策略实现 **************************/
// ADXL345初始化（具体策略实现，严格遵循统一接口）
static uint8_t adxl345_init(SensorDev *dev, uint16_t sample_rate) {
dev->i2c_addr = 0x53; // ADXL345默认I2C地址（差异化参数）
dev->sample_rate = sample_rate;

// ADXL345初始化（配置电源、采样频率，参考 datasheet）
I2C_WriteByte(dev->i2c_addr, 0x2D, 0x08); // 唤醒ADXL345（差异化配置）
I2C_WriteByte(dev->i2c_addr, 0x2C, (sample_rate <= 100) ? 0x0A : 0x0E);

printf("ADXL345 init success, sample rate: %d Hz\\r\\n", sample_rate);
return 0;
}

// ADXL345读取加速度数据（具体策略实现，严格遵循统一接口）
static uint8_t adxl345_read_accel(SensorDev *dev, int16_t *accel_data) {
uint8_t data[6];
I2C_ReadBytes(dev->i2c_addr, 0x32, 6, data); // ADXL345差异化寄存器地址

// ADXL345数据转换（差异化换算逻辑）
accel_data[0] = (data[1] << 8) | data[0];
accel_data[1] = (data[3] << 8) | data[2];
accel_data[2] = (data[5] << 8) | data[4];

dev->accel_data[0] = accel_data[0];
dev->accel_data[1] = accel_data[1];
dev->accel_data[2] = accel_data[2];

return 0;
}

// ADXL345其他接口实现（省略，遵循统一接口）
static uint8_t adxl345_write_reg(SensorDev *dev, uint8_t reg_addr, uint8_t data) {
return I2C_WriteByte(dev->i2c_addr, reg_addr, data);
}

static void adxl345_deinit(SensorDev *dev) {
I2C_WriteByte(dev->i2c_addr, 0x2D, 0x00); // 睡眠模式（差异化配置）
printf("ADXL345 deinit success\\r\\n");
}

static SensorStrategy adxl345_strategy = {
.init = adxl345_init,
.read_accel = adxl345_read_accel,
.write_reg = adxl345_write_reg,
.deinit = adxl345_deinit
};

3.3 第三步：实现工厂模式，统一创建驱动实例

实现传感器工厂的初始化和驱动实例创建接口，工厂的核心作用是将具体的策略注册到策略数组中，外部业务代码只需调用工厂接口，传入传感器类型，即可自动创建对应的驱动实例，无需关注具体的驱动实现细节，简化业务层调用。

/************************** 传感器工厂实现（工厂模式核心） **************************/
// 工厂初始化：注册所有传感器策略（新增传感器时，只需新增一行注册代码）
void sensor_factory_init(void) {
// 将每种传感器的策略注册到工厂的策略数组中，与传感器类型枚举一一对应
sensor_factory.strategies[SENSOR_MPU6050] = mpu6050_strategy;
sensor_factory.strategies[SENSOR_BMI088] = bmi088_strategy;
sensor_factory.strategies[SENSOR_ADXL345] = adxl345_strategy;

printf("Sensor factory init success, support %d sensors\\r\\n", SENSOR_MAX);
}

// 工厂创建驱动实例：根据传感器类型，返回对应的驱动实例（核心接口，供业务层调用）
SensorDev* sensor_factory_create(SensorType type, uint16_t sample_rate) {
// 边界判断：传感器类型无效（避免越界，提升代码健壮性）
if (type >= SENSOR_MAX) {
printf("Error: Unsupported sensor type\\r\\n");
return NULL;
}

// 初始化传感器实例（绑定类型和策略，统一初始化流程）
sensor_dev.type = type;
SensorStrategy *strategy = &sensor_factory.strategies[type];

// 调用对应传感器的初始化函数（策略模式核心：统一接口调用不同实现）
if (strategy->init(&sensor_dev, sample_rate) != 0) {
printf("Error: Sensor %d init failed\\r\\n", type);
return NULL;
}

return &sensor_dev; // 返回初始化完成的驱动实例，供业务层使用
}

/************************** 外部统一调用接口（业务层使用） **************************/
// 读取传感器加速度数据（统一接口，业务层无需关注具体传感器类型）
uint8_t sensor_read_accel(SensorDev *dev, int16_t *accel_data) {
if (dev == NULL || dev->type >= SENSOR_MAX) {
return 1; // 失败返回1，统一返回值规范
}
// 调用对应策略的读取函数（统一接口，屏蔽差异化，简化业务层调用）
return sensor_factory.strategies[dev->type].read_accel(dev, accel_data);
}

// 写入传感器寄存器（统一接口，业务层通用调用）
uint8_t sensor_write_reg(SensorDev *dev, uint8_t reg_addr, uint8_t data) {
if (dev == NULL || dev->type >= SENSOR_MAX) {
return 1;
}
return sensor_factory.strategies[dev->type].write_reg(dev, reg_addr, data);
}

// 关闭传感器（统一接口，业务层通用调用，适配低功耗需求）
void sensor_deinit(SensorDev *dev) {
if (dev == NULL || dev->type >= SENSOR_MAX) {
return;
}
sensor_factory.strategies[dev->type].deinit(dev);
}

3.4 第四步：业务层调用示例（重构后的简洁效果）

重构完成后，业务层代码无需关注具体的传感器驱动逻辑，只需调用工厂接口创建实例，通过统一接口操作传感器，代码简洁、可读性高，新增或切换传感器时，无需修改业务层核心代码，大幅提升开发和维护效率。

int main(void) {
SensorDev *dev = NULL;
int16_t accel_data[3];

// 1. 初始化传感器工厂（注册所有策略，仅需调用一次）
sensor_factory_init();

// 2. 工厂创建传感器实例（传入类型和采样频率，无需手动判断传感器类型）
// 可直接切换为 SENSOR_BMI088、SENSOR_ADXL345，无需修改其他代码，扩展性极强
dev = sensor_factory_create(SENSOR_MPU6050, 100); // 创建MPU6050实例，采样频率100Hz
if (dev == NULL) {
while (1); // 初始化失败，死机提示（嵌入式常用容错处理）
}

// 3. 业务逻辑：循环读取加速度数据（统一接口调用，屏蔽所有差异化）
while (1) {
if (sensor_read_accel(dev, accel_data) == 0) {
printf("Accel Data: X=%d, Y=%d, Z=%d\\r\\n",
accel_data[0], accel_data[1], accel_data[2]);
}

// 延时（模拟业务逻辑，可根据实际需求修改）
for (uint32_t i=0; i<1000000; i++);
}

// 4. 关闭传感器（统一接口调用，适配低功耗场景）
sensor_deinit(dev);
return 0;
}

四、实战验证：重构安全保障与测试技巧

嵌入式开发中，重构的核心风险是“修改代码后导致功能异常”，尤其是legacy代码往往缺乏完善的测试用例，一旦出错可能影响产品稳定性。因此，我们需要借助工具和标准化测试流程，确保重构前后功能一致、运行稳定，同时验证重构效果是否达到预期。

4.1 重构安全保障工具与技巧

实战操作：将重构后的代码导入Cppcheck，开启“嵌入式C语言适配”模式，扫描后根据提示逐一修改问题，确保代码语法规范、无潜在隐患，适配DSP/MCU的编译环境。

核心测试用例（嵌入式实操必测）：① 每种传感器的初始化是否成功；② 数据读取是否准确（可对比legacy代码的输出结果）；③ 切换传感器类型时，驱动是否正常切换，无功能异常；④ 新增传感器驱动时，原有代码是否无需修改，可直接适配。

4.2 重构效果验证标准

重构完成后，需从“功能、性能、可维护性”三个维度验证效果，确保达到预期目标，贴合嵌入式实操需求，具体标准如下：

五、问题解决：重构实战中常见问题及解决方案

结合多年嵌入式DSP C重构实战经验，整理了4个最常见的问题、核心原因及可直接落地的解决方案，帮你快速避坑，提高重构效率，避免在调试中浪费时间，贴合嵌入式实操场景。

5.1 问题1：重构后代码运行效率下降，CPU占用率升高

原因：过度封装接口，导致函数调用层级过多，增加CPU运算开销；使用动态内存分配（如malloc），增加内存开销和运算耗时；策略数组遍历耗时过长，影响代码运行效率。

解决方案：减少不必要的接口封装，保持函数调用层级不超过3层，降低运算开销；避免使用动态内存分配，采用全局实例或静态变量（如本次实战中的sensor_dev），减少内存开销；传感器类型较少时，无需遍历策略数组，直接通过枚举值索引（本次实现已优化，可直接复用）。

5.2 问题2：重构后传感器驱动功能异常，数据读取错误

原因：重构过程中误改了传感器的寄存器配置、数据转换逻辑；接口参数传递错误（如I2C地址、寄存器地址填写错误）；策略注册错误，工厂未绑定正确的策略实现，导致调用异常。

解决方案：对比legacy代码，逐一核对寄存器配置、数据转换逻辑，确保无修改偏差，重点核对差异化参数；打印接口参数（如I2C地址、寄存器地址），排查参数传递错误；检查工厂初始化函数，确保每种传感器的策略都正确注册到对应枚举值，无注册遗漏或错误。

5.3 问题3：新增传感器驱动时，无法适配现有接口

原因：新传感器的驱动逻辑与现有接口差异较大（如无需I2C通信，采用SPI通信）；现有接口定义不够通用，包含了特定传感器的属性（如仅适配I2C通信），扩展性不足。

解决方案：优化接口设计，提取所有传感器的通用操作，将差异化属性（如通信方式）封装到传感器数据结构体中（如新增comm_type字段，标记I2C/SPI）；新增对应通信接口（如SPI读写函数），在策略实现中根据通信方式调用对应底层函数，不修改现有接口，确保接口兼容性和扩展性。

5.4 问题4：单元测试难以编写，无法覆盖所有驱动逻辑

原因：驱动逻辑与底层硬件（如I2C）耦合过紧，无法脱离硬件进行单元测试；缺乏模拟底层接口的方法，测试时依赖实际硬件，难以覆盖所有场景。

解决方案：将底层硬件接口（如I2C读写）封装为独立的函数，实现驱动逻辑与底层硬件解耦；单元测试时，用模拟函数替代真实底层接口，返回预设的测试数据，脱离硬件即可完成测试；聚焦核心驱动逻辑（如数据转换、寄存器配置）编写测试用例，无需测试底层硬件通信的正确性，提升测试效率。

六、总结与互动引导

本次实战案例，围绕嵌入式legacy C代码的重构痛点，完整实现了“工厂模式+策略模式”优化硬件驱动代码的全过程，从原理拆解、工程化分析，到C语言实操实现、实战验证调试，全程贴合DSP C开发者的实操需求，无冗余理论，所有代码均可直接复制移植，新手也能快速上手。

核心收获：设计模式并非高级语言专属，C语言也能通过结构体、函数指针，实现简单实用的设计模式，高效解决legacy代码的冗余、混乱、难维护等痛点；重构的核心是“不改变功能、优化结构”，尤其是嵌入式开发，要兼顾代码可维护性和硬件资源限制，选择适配的设计模式和重构策略，避免过度设计，实用才是关键。

对嵌入式开发者而言，写出“能跑的代码”很容易，但写出“易维护、可扩展的代码”，才是提升核心竞争力的关键。本次重构思路和设计模式组合，不仅适用于传感器驱动，还可推广到其他legacy C代码场景（如外设驱动、协议解析），帮你彻底摆脱“改bug难、加功能难”的困境，提升开发效率和代码质量。

如果本文对你的legacy代码重构、嵌入式C代码优化有帮助，记得点赞、收藏、关注哦！如果在实操过程中遇到问题，或者有更好的重构技巧、设计模式选型建议，欢迎在评论区留言交流，一起避坑、一起提升，写出更优雅、更高效的嵌入式C代码～