嵌入式开发必杀技：策略模式实战指南，告别if-else地狱！

上一篇我们分享了【bufferevent | 嵌入式网络通信缓冲层】，其中bufferevent 采用了 策略模式 设计，通过 struct bufferevent_ops 实现多态行为：

不同类型的 bufferevent（如 socket、filter、SSL）共享同一套接口，通过 be_ops 指针调用各自的实现函数。

这篇文章我们来分享策略模式相关的内容：

策略模式

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

策略模式包含以下主要角色：

上下文（Context）：持有一个策略对象的引用，用于调用策略。

策略接口（Strategy）：定义所有支持的算法或行为的公共接口。

具体策略（Concrete Strategies）：实现策略接口的具体类，提供具体的算法实现。

在嵌入式系统中，该模式尤其适用于：

通信协议切换：在UART/I2C/SPI之间动态切换

传感器数据处理：针对不同传感器类型（温度/湿度/光感）使用不同处理策略

电源管理：根据电源状态（电池/外接电源）切换功耗策略

控制算法：在PID控制、模糊控制等算法间动态切换

策略模式 vs 非策略模式：

嵌入式应用案例

传感器数据处理：针对不同传感器类型（温度/湿度）使用不同处理策略。

代码实现：

1、上下文（Context）：

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

2、策略接口（Strategy）：

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

3、具体策略（Concrete Strategies）：

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

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

C语言完整例子：

#include <stdio.h>

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

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

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

// 传感器处理器（上下文）
typedefstruct {
    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);
    
    return0;
}

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 << "Cn";
    }
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();
    
    return0;
}

优缺点

优点：

开闭原则：无需修改上下文即可引入新策略

消除条件分支：替代复杂的if-else/switch语句

关注点分离：算法实现与使用逻辑解耦

缺点：

对象数量增加：每个策略都是独立类/对象

客户端认知负担：需了解不同策略的差异

过度设计风险：简单算法可能不需要策略模式

嵌入式场景适用性总结