嵌入式开发策略模式实战与优化

设计模式是软件工程中解决常见问题的经典方案，其中策略模式通过封装可变算法实现运行时灵活切换。其核心原理是将算法族定义为独立策略对象，通过上下文类进行统一调用，符合开闭原则和单一职责原则。在嵌入式系统开发中，策略模式能有效处理多传感器数据处理、通信协议切换等典型场景，相比传统条件分支方式更易于扩展和维护。通过C/C++的函数指针和面向对象特性，可以在资源受限环境下实现策略模式，同时结合静态分配、策略

赵阿萌

478人浏览 · 2026-03-27 09:51:17

赵阿萌 · 2026-03-27 09:51:17 发布

嵌入式开发中的策略模式实战指南

1. 策略模式概述

1.1 基本概念

策略模式(Strategy Pattern)是一种行为设计模式，它定义了一系列算法，并将每个算法封装成独立的对象，使它们可以相互替换。这种模式让算法的变化独立于使用算法的客户端。

1.2 核心组件

策略模式包含三个主要角色：

上下文(Context) ：持有一个策略对象的引用，用于调用策略
策略接口(Strategy) ：定义所有支持的算法或行为的公共接口
具体策略(Concrete Strategies) ：实现策略接口的具体类，提供具体的算法实现

2. 嵌入式系统中的策略模式应用

2.1 典型应用场景

在嵌入式系统开发中，策略模式特别适用于以下场景：

通信协议切换 ：在UART/I2C/SPI之间动态切换
传感器数据处理 ：针对不同传感器类型(温度/湿度/光感)使用不同处理策略
电源管理 ：根据电源状态(电池/外接电源)切换功耗策略
控制算法 ：在PID控制、模糊控制等算法间动态切换

2.2 策略模式优势分析

与传统条件分支方式相比，策略模式具有显著优势：

特性	策略模式	非策略模式
算法扩展	添加新策略无需修改上下文	需要修改核心逻辑
条件分支	消除复杂switch/case语句	大量条件分支语句
代码复用	策略对象可在不同上下文复用	算法逻辑与使用场景紧耦合
运行时灵活性	可动态切换算法	编译时确定行为
测试复杂度	策略对象可独立测试	需要模拟整个上下文环境

3. 策略模式实现案例

3.1 传感器数据处理示例

3.1.1 C语言实现

#include <stdio.h>

// 策略接口
typedef void (*SensorStrategy)(void* data);

// 温度传感器策略
void temperature_strategy(void* data) {
    float* temp = (float*)data;
    printf("[C] Processing temperature: %.1fC -> Calibrated: %.1fC\n", 
           *temp, *temp + 0.5f);
}

// 湿度传感器策略
void humidity_strategy(void* data) {
    int* humidity = (int*)data;
    printf("[C] Processing humidity: %d%% -> Adjusted: %d%%\n", 
           *humidity, *humidity + 2);
}

// 传感器处理器（上下文）
typedef struct {
    SensorStrategy strategy;
    void* sensor_data;
} SensorProcessor;

void process_sensor(SensorProcessor* processor) {
    processor->strategy(processor->sensor_data);
}

int main(void) {
    printf("\n--- Strategy Pattern Demo ---\n");
    
    float temp_data = 25.3f;
    int humidity_data = 45;
    
    SensorProcessor temp_processor = {temperature_strategy, &temp_data};
    SensorProcessor hum_processor = {humidity_strategy, &humidity_data};
    
    process_sensor(&temp_processor);
    process_sensor(&hum_processor);
    
    return 0;
}

3.1.2 C++实现

#include <iostream>
#include <memory>

// 策略接口
class SensorStrategy {
public:
    virtual void process() = 0;
    virtual ~SensorStrategy() = default;
};

// 温度传感器策略
class TemperatureStrategy : public SensorStrategy {
public:
    explicit TemperatureStrategy(float temp) : temp_(temp) {}
    void process() override {
        std::cout << "Processing temperature: " << temp_ 
                  << "C -> Calibrated: " << temp_ + 0.5f << "C\n";
    }
private:
    float temp_;
};

// 湿度传感器策略
class HumidityStrategy : public SensorStrategy {
public:
    explicit HumidityStrategy(int humidity) : humidity_(humidity) {}
    void process() override {
        std::cout << "Processing humidity: " << humidity_ 
                  << "% -> Adjusted: " << humidity_ + 2 << "%\n";
    }
private:
    int humidity_;
};

// 传感器处理器（上下文）
class SensorProcessor {
public:
    void set_strategy(std::unique_ptr<SensorStrategy> strategy) {
        strategy_ = std::move(strategy);
    }
    void process_sensor() {
        if(strategy_) strategy_->process();
    }
private:
    std::unique_ptr<SensorStrategy> strategy_;
};

int main(void) {
    std::cout << "\n--- Strategy Pattern Demo ---\n";
    
    SensorProcessor processor;
    processor.set_strategy(std::make_unique<TemperatureStrategy>(25.3f));
    processor.process_sensor();
    
    processor.set_strategy(std::make_unique<HumidityStrategy>(45));
    processor.process_sensor();
    
    return 0;
}

3.2 通信协议切换示例

// 通信策略接口
typedef struct {
    void (*init)(void);
    void (*send)(const uint8_t* data, size_t length);
    void (*receive)(uint8_t* buffer, size_t max_length);
} CommStrategy;

// UART策略实现
static const CommStrategy uart_strategy = {
    .init = uart_init,
    .send = uart_send,
    .receive = uart_receive
};

// SPI策略实现
static const CommStrategy spi_strategy = {
    .init = spi_init,
    .send = spi_send,
    .receive = spi_receive
};

// 通信上下文
typedef struct {
    const CommStrategy* strategy;
} CommunicationContext;

void comm_init(CommunicationContext* ctx) {
    ctx->strategy->init();
}

void comm_send(CommunicationContext* ctx, const uint8_t* data, size_t length) {
    ctx->strategy->send(data, length);
}

void comm_receive(CommunicationContext* ctx, uint8_t* buffer, size_t max_length) {
    ctx->strategy->receive(buffer, max_length);
}