策略模式及优化

快乐的划水a2025-07-17 16:30

策略模式（Strategy Pattern）是一种行为设计模式，其核心思想是将算法的定义与使用分离，使算法可以独立于客户端进行变化。它通过定义一系列算法，将每个算法封装到独立的类中，并使它们可以互相替换，从而让算法的变化不会影响到使用算法的客户端。

介绍

策略模式的核心组件

  1. 策略接口（Strategy Interface） ：

    定义所有具体策略必须实现的公共方法，通常是一个抽象类或接口。例如，在排序场景中，策略接口可能定义sort()方法。

  2. 具体策略（Concrete Strategies） ：

    实现策略接口的具体算法类。例如：BubbleSort、QuickSort、MergeSort等。

  3. 上下文（Context） ：

    持有一个策略接口的引用，负责根据需要动态切换具体策略。上下文不直接实现算法，而是将工作委托给策略对象。

  4. 客户端（Client） ：

    负责创建具体策略并将其注入到上下文中，控制策略的选择逻辑。

策略模式的特点

  1. 可替换性 ：

    客户端可以在运行时动态切换策略，无需修改上下文代码。

  2. 开闭原则 ：

    新增策略只需实现接口，无需修改现有代码，符合"对扩展开放，对修改关闭"的原则。

  3. 解耦算法 ：

    算法的实现细节被封装在具体策略中，客户端无需关心其内部逻辑。

  4. 消除条件语句 ：

    避免使用大量if-else或switch语句来选择算法，使代码更简洁。

适用场景
  1. 多种算法选择：当一个问题有多种解决算法，且需要在运行时动态切换时。
  2. 避免条件语句 ：替代大量的if-else或switch语句，使代码更清晰。
  3. 算法封装：将算法的实现细节与使用算法的客户端代码分离。

实现

cpp 复制代码 
#include <iostream>
#include <memory>
#include <string>

// 策略接口：定义算法族
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) const = 0;
};

// 具体策略：冒泡排序
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) const override {
        std::cout << "使用冒泡排序..." << std::endl;
        // 冒泡排序实现
        int n = data.size();
        for (int i = 0; i < n - 1; ++i) {
            for (int j = 0; j < n - i - 1; ++j) {
                if (data[j] > data[j + 1]) {
                    std::swap(data[j], data[j + 1]);
                }
            }
        }
    }
};

// 具体策略：快速排序
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) const override {
        std::cout << "使用快速排序..." << std::endl;
        // 快速排序实现
        quickSort(data, 0, data.size() - 1);
    }

private:
    void quickSort(std::vector<int>& data, int left, int right) const {
        if (left < right) {
            int pivotIndex = partition(data, left, right);
            quickSort(data, left, pivotIndex - 1);
            quickSort(data, pivotIndex + 1, right);
        }
    }

    int partition(std::vector<int>& data, int left, int right) const {
        int pivot = data[right];
        int i = left - 1;
        for (int j = left; j < right; ++j) {
            if (data[j] <= pivot) {
                ++i;
                std::swap(data[i], data[j]);
            }
        }
        std::swap(data[i + 1], data[right]);
        return i + 1;
    }
};

// 上下文：维护一个策略引用
class Sorter {
private:
    std::unique_ptr<SortStrategy> strategy;

public:
    explicit Sorter(std::unique_ptr<SortStrategy> strategy)
        : strategy(std::move(strategy)) {}

    void setStrategy(std::unique_ptr<SortStrategy> strategy) {
        this->strategy = std::move(strategy);
    }

    void performSort(std::vector<int>& data) const {
        if (strategy) {
            strategy->sort(data);
        } else {
            std::cout << "未设置排序策略" << std::endl;
        }
    }
};

// 客户端代码
int main() {
    std::vector<int> data = {5, 4, 3, 2, 1};

    // 使用冒泡排序
    Sorter sorter(std::make_unique<BubbleSort>());
    sorter.performSort(data);
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 切换为快速排序
    data = {5, 4, 3, 2, 1};
    sorter.setStrategy(std::make_unique<QuickSort>());
    sorter.performSort(data);
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}
应用场景
  1. 排序算法切换：根据数据规模选择冒泡排序、快速排序等。
  2. 支付方式：电商系统中支持支付宝、微信、银行卡等多种支付方式。
  3. 压缩算法：文件压缩工具支持ZIP、RAR、7Z等不同压缩算法。
  4. 游戏AI：不同难度的敌人使用不同的行为策略。
  5. 加密算法：安全系统中动态选择加密方式（MD5、SHA-256等）。
策略模式与其他模式的对比
模式 核心区别
策略模式 算法的定义与使用分离，强调运行时动态切换。
状态模式 行为随内部状态变化而变化，状态转换通常由上下文触发。
工厂模式 专注于对象的创建，而不涉及对象的行为。

策略模式优化（注册机制和反射）

优化措施

  1. 策略工厂与注册机制：

    • StrategyFactory 使用单例模式管理策略的创建
    • 通过 registerStrategy 方法注册策略名称和对应的工厂函数
    • StrategyRegistrar 模板类用于静态注册，避免手动调用注册函数

  2. 反射机制：

    • 使用 std::function 和 lambda 表达式实现类型擦除
    • 通过字符串名称动态创建策略对象
    • 静态注册确保在程序初始化时完成所有策略的注册

  3. Sorter类改进：

    • 在构造函数中初始化所有策略实例
    • 使用 std::unordered_map 管理策略对象
    • 通过 setStrategy 方法动态切换当前使用的策略
    • 所有策略对象仅创建一次，提高性能
cpp 复制代码 
#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <unordered_map>
#include <functional>

// 策略接口
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) const = 0;
};

// 具体策略：冒泡排序
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) const override {
        std::cout << "使用冒泡排序..." << std::endl;
        int n = data.size();
        for (int i = 0; i < n - 1; ++i) {
            for (int j = 0; j < n - i - 1; ++j) {
                if (data[j] > data[j + 1]) {
                    std::swap(data[j], data[j + 1]);
                }
            }
        }
    }
};

// 具体策略：快速排序
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) const override {
        std::cout << "使用快速排序..." << std::endl;
        quickSort(data, 0, data.size() - 1);
    }

private:
    void quickSort(std::vector<int>& data, int left, int right) const {
        if (left < right) {
            int pivotIndex = partition(data, left, right);
            quickSort(data, left, pivotIndex - 1);
            quickSort(data, pivotIndex + 1, right);
        }
    }

    int partition(std::vector<int>& data, int left, int right) const {
        int pivot = data[right];
        int i = left - 1;
        for (int j = left; j < right; ++j) {
            if (data[j] <= pivot) {
                ++i;
                std::swap(data[i], data[j]);
            }
        }
        std::swap(data[i + 1], data[right]);
        return i + 1;
    }
};

// 策略工厂：负责创建策略实例
class StrategyFactory {
public:
    static StrategyFactory& getInstance() {
        static StrategyFactory instance;
        return instance;
    }

    void registerStrategy(const std::string& name, std::function<std::unique_ptr<SortStrategy>()> factory) {
        factories[name] = factory;
    }

    std::unique_ptr<SortStrategy> createStrategy(const std::string& name) {
        auto it = factories.find(name);
        if (it != factories.end()) {
            return it->second();
        }
        return nullptr;
    }

private:
    StrategyFactory() = default;
    std::unordered_map<std::string, std::function<std::unique_ptr<SortStrategy>()>> factories;
};

// 策略注册表：静态注册策略
template<typename T>
struct StrategyRegistrar {
    StrategyRegistrar(const std::string& name) {
        StrategyFactory::getInstance().registerStrategy(name, []() {
            return std::make_unique<T>();
        });
    }
};

// 上下文：维护策略并提供排序功能
class Sorter {
public:
    Sorter() {
        strategies["bubble"] = StrategyFactory::getInstance().createStrategy("bubble");
        strategies["quick"] = StrategyFactory::getInstance().createStrategy("quick");
        currentStrategy = strategies["bubble"].get();
    }

    void setStrategy(const std::string& name) {
        auto it = strategies.find(name);
        if (it != strategies.end()) {
            currentStrategy = it->second.get();
        } else {
            std::cout << "未找到策略: " << name << std::endl;
        }
    }

    void performSort(std::vector<int>& data) const {
        if (currentStrategy) {
            currentStrategy->sort(data);
        } else {
            std::cout << "未设置排序策略" << std::endl;
        }
    }

private:
    std::unordered_map<std::string, std::unique_ptr<SortStrategy>> strategies;
    SortStrategy* currentStrategy;
};

// 静态注册策略
static StrategyRegistrar<BubbleSort> bubbleRegistrar("bubble");
static StrategyRegistrar<QuickSort> quickRegistrar("quick");

// 客户端代码
int main() {
    std::vector<int> data = {5, 4, 3, 2, 1};

    Sorter sorter;

    // 使用冒泡排序
    sorter.setStrategy("bubble");
    sorter.performSort(data);
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 切换为快速排序
    data = {5, 4, 3, 2, 1};
    sorter.setStrategy("quick");
    sorter.performSort(data);
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

添加新策略时，只需：

  1. 创建新的策略类，继承自 SortStrategy

  2. 实现 sort 方法

  3. 添加静态注册语句：

    cpp 复制代码 
    static StrategyRegistrar<NewSortStrategy> newRegistrar("new");

// 无需修改 Sorter 类，完全符合开闭原则。

客户端通过字符串名称即可使用新策略，实现了对修改封闭，对扩展开放的设计目标。

热门推荐
01Cursor Claude 模型无法使用的解决方法02全球最强模型Grok4，国内已可免费使用！（附教程）03KGG转MP3工具|非KGM文件|解密音频04Cursor如何配置代理05【无标题】06集群聊天服务器---MySQL数据库的建立07突破限制：使用 Claude Code Proxy 让 Claude Code 自由连接任意模型08绿色建筑新态势：楼宇自控助力能效提升，推动成本优化新路径09Coze扣子平台完整体验和实践（附国内和国际版对比）10（5千字总结）国内如何安装和使用 Claude Code 的保姆级教程 - 支持Mac和Windows用户