C++策略模式与模板方法模式的适用场景对比-源码库

C++策略模式与模板方法模式的适用场景对比：从实战角度解析两种行为型设计模式

作为一名有着多年C++开发经验的程序员，我在项目重构和架构设计中经常面临这样的抉择：当需要封装算法或行为时，到底该选择策略模式还是模板方法模式？这两种模式看似相似，实则有着截然不同的适用场景。今天我就结合自己的实战经验，带大家深入理解这两种模式的核心差异和最佳使用时机。

1. 初识两种模式：概念与基本结构

记得我第一次接触设计模式时，也常常混淆策略模式和模板方法模式。经过多个项目的实践，我才真正理解了它们的本质区别。

策略模式通过组合的方式，将算法族封装成独立的策略类，使得它们可以相互替换。这种模式让算法的变化独立于使用算法的客户。而模板方法模式则使用继承，在父类中定义算法的骨架，将某些步骤延迟到子类中实现。

让我用代码来展示它们的基本结构差异。首先是策略模式：


// 策略接口
class SortingStrategy {
public:
    virtual ~SortingStrategy() = default;
    virtual void sort(vector& data) = 0;
};

// 具体策略
class QuickSort : public SortingStrategy {
public:
    void sort(vector& data) override {
        // 快速排序实现
        cout << "使用快速排序" << endl;
    }
};

class MergeSort : public SortingStrategy {
public:
    void sort(vector& data) override {
        // 归并排序实现
        cout << "使用归并排序" << endl;
    }
};

// 上下文
class Sorter {
private:
    SortingStrategy* strategy;
public:
    Sorter(SortingStrategy* strategy) : strategy(strategy) {}
    
    void setStrategy(SortingStrategy* newStrategy) {
        strategy = newStrategy;
    }
    
    void executeSort(vector& data) {
        strategy->sort(data);
    }
};

再来看看模板方法模式：


// 抽象基类定义模板方法
class DataProcessor {
public:
    virtual ~DataProcessor() = default;
    
    // 模板方法 - 定义算法骨架
    void process() {
        loadData();
        transformData();
        saveData();
        cleanup();
    }
    
protected:
    virtual void loadData() = 0;
    virtual void transformData() = 0;
    
    void saveData() {
        // 固定的保存逻辑
        cout << "保存数据到数据库" << endl;
    }
    
    void cleanup() {
        // 固定的清理逻辑
        cout << "清理临时资源" << endl;
    }
};

// 具体实现
class CSVProcessor : public DataProcessor {
protected:
    void loadData() override {
        cout << "从CSV文件加载数据" << endl;
    }
    
    void transformData() override {
        cout << "对CSV数据进行转换" << endl;
    }
};

class XMLProcessor : public DataProcessor {
protected:
    void loadData() override {
        cout << "从XML文件加载数据" << endl;
    }
    
    void transformData() override {
        cout << "对XML数据进行转换" << endl;
    }
};

2. 核心差异分析：运行时动态替换 vs 编译时静态绑定

在实际项目中，我深刻体会到两种模式最根本的区别在于灵活性。策略模式支持在运行时动态替换算法，而模板方法模式的算法骨架在编译时就已经确定。

让我分享一个真实案例：在开发一个图像处理应用时，我们需要支持多种滤镜算法。如果使用策略模式：


class ImageFilter {
private:
    FilterStrategy* strategy;
public:
    void setFilter(FilterStrategy* newStrategy) {
        strategy = newStrategy;
    }
    
    void applyFilter(Image& image) {
        strategy->apply(image);
    }
};

// 在运行时可以根据用户选择切换滤镜
imageFilter.setFilter(new BlurFilter());
imageFilter.applyFilter(image);

// 用户切换滤镜
imageFilter.setFilter(new SharpeningFilter());
imageFilter.applyFilter(image);

而当我需要实现一个数据处理流水线时，模板方法模式就更加合适：


class DataPipeline {
public:
    void runPipeline() {
        // 固定的流水线步骤
        validateInput();
        preprocess();
        executeCoreLogic();  // 这是需要子类实现的核心逻辑
        postprocess();
        generateReport();
    }
    
protected:
    virtual void executeCoreLogic() = 0;
    
private:
    void validateInput() { /* 固定实现 */ }
    void preprocess() { /* 固定实现 */ }
    void postprocess() { /* 固定实现 */ }
    void generateReport() { /* 固定实现 */ }
};

3. 实战场景选择：何时用策略，何时用模板

经过多个项目的摸爬滚打，我总结出了一套实用的选择标准：

选择策略模式的场景：

需要在运行时切换算法或行为
有多个相关的类，只在行为上有所不同
需要避免使用多重条件转移语句
算法的具体实现对客户端应该是透明的

选择模板方法模式的场景：

算法的整体结构固定，但某些步骤需要变化
希望在不变换算法结构的情况下重新定义某些步骤
需要控制子类的扩展，确保算法骨架不被破坏
存在多个类包含几乎相同的算法，只有细微差别

让我用一个配置管理的例子来说明。当我们需要支持多种配置源（文件、数据库、网络）时，策略模式是更好的选择：


class ConfigManager {
private:
    ConfigLoaderStrategy* loader;
public:
    void setLoader(ConfigLoaderStrategy* newLoader) {
        loader = newLoader;
    }
    
    Config loadConfig() {
        return loader->load();
    }
};

而当我们需要实现一个报表生成器，生成流程固定但数据源不同时，模板方法模式更合适：


class ReportGenerator {
public:
    void generate() {
        connectDataSource();
        fetchData();
        formatReport();  // 子类实现具体格式
        exportReport();
    }
    
protected:
    virtual void formatReport() = 0;
};

4. 性能与维护性考量

在实际项目中，性能和维护性往往是重要的考量因素。策略模式由于使用虚函数和动态绑定，在性能上会有轻微开销，但提供了极大的灵活性。模板方法模式在性能上更优，因为很多调用在编译时就能确定。

从维护角度看，策略模式更容易扩展新的算法，符合开闭原则。模板方法模式在算法结构稳定但具体实现可能变化时，维护性更好。

我在一个高性能计算项目中就遇到了这样的权衡：


// 策略模式 - 灵活但有一定性能开销
class NumericalIntegrator {
private:
    IntegrationStrategy* strategy;
public:
    double integrate(std::function f, double a, double b) {
        return strategy->compute(f, a, b);
    }
};

// 模板方法模式 - 性能更优
template
class TemplateIntegrator {
public:
    double integrate(std::function f, double a, double b) {
        setup();
        double result = compute(f, a, b);  // 编译时确定
        cleanup();
        return result;
    }
    
private:
    double compute(std::function f, double a, double b) {
        return Method::compute(f, a, b);
    }
};

5. 结合使用的实战技巧

在实际开发中，两种模式并不是互斥的。我经常将它们结合使用，发挥各自的优势。比如在一个游戏开发项目中：


// 模板方法定义角色行为骨架
class GameCharacter {
public:
    void performAction() {
        prepare();
        executeAction();  // 使用策略模式
        cleanup();
    }
    
    void setActionStrategy(ActionStrategy* strategy) {
        actionStrategy = strategy;
    }
    
private:
    ActionStrategy* actionStrategy;
    
    void executeAction() {
        actionStrategy->execute();
    }
};

// 策略接口
class ActionStrategy {
public:
    virtual void execute() = 0;
};

class AttackStrategy : public ActionStrategy {
public:
    void execute() override {
        // 攻击逻辑
    }
};

class DefenseStrategy : public ActionStrategy {
public:
    void execute() override {
        // 防御逻辑
    }
};