策略模式（C++）

Posted 2023-04-06 1037号森林里一段干木头

简介

策略模式是一种行为型设计模式，它定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换，且不影响客户端的使用。策略模式的目的是将算法的使用与实现分离，降低了算法之间的耦合，提高了代码的可扩展性和可维护性。

策略模式适用于以下场景：

• 当有多种算法可以实现同一个功能，但是客户端需要根据不同的情况选择不同的算法时，可以使用策略模式。
• 当一个类定义了多种行为，且这些行为在这个类的操作中以多个条件语句的形式出现时，可以使用策略模式将每个行为封装为一个策略类，消除这些条件语句。
• 当一个系统需要动态地在几种算法中选择一种时，可以使用策略模式。

策略模式的常用技巧有：

• 定义一个抽象策略接口，用于规范所有具体策略类的行为。
• 定义一个上下文类，用于维护一个策略对象的引用，并提供一个方法让客户端可以设置或更换策略对象。
• 定义一系列具体策略类，实现抽象策略接口，并封装各自的算法逻辑。
• 客户端通过创建上下文对象，并传入具体策略对象，来使用不同的算法。客户端可以在运行时更换策略对象，实现动态切换算法的功能。

策略模式是一种简单而有效的设计模式，它可以帮助我们实现高内聚低耦合的代码设计原则，提高系统的灵活性和可复用性。

C++示例

#include <iostream>
#include <vector>
#include <algorithm>

// 定义排序策略接口
class SortStrategy 
public:
    virtual void sort(std::vector<int>& nums) = 0;
;

// 实现冒泡排序策略
class BubbleSort : public SortStrategy 
public:
    void sort(std::vector<int>& nums) override 
        int n = nums.size();
        for (int i = 0; i < n - 1; i++) 
            for (int j = 0; j < n - i - 1; j++) 
                if (nums[j] > nums[j + 1]) 
                    std::swap(nums[j], nums[j + 1]);
                
            
        
    
;

// 实现快速排序策略
class QuickSort : public SortStrategy 
public:
    void sort(std::vector<int>& nums) override 
        quickSort(nums, 0, nums.size() - 1);
    

private:
    void quickSort(std::vector<int>& nums, int left, int right) 
        if (left >= right) 
            return;
        
        int pivot = partition(nums, left, right);
        quickSort(nums, left, pivot - 1);
        quickSort(nums, pivot + 1, right);
    

    int partition(std::vector<int>& nums, int left, int right) 
        int pivot = nums[right];
        int i = left;
        for (int j = left; j < right; j++) 
            if (nums[j] < pivot) 
                std::swap(nums[i], nums[j]);
                i++;
            
        
        std::swap(nums[i], nums[right]);
        return i;
    
;

// 定义排序类，使用策略模式
class Sorter 
public:
    Sorter(SortStrategy* strategy) : strategy_(strategy) 

    void setStrategy(SortStrategy* strategy) 
        strategy_ = strategy;
    

    void sort(std::vector<int>& nums) 
        strategy_->sort(nums);
    

private:
    SortStrategy* strategy_;
;

int main() 
    std::vector<int> nums = 3, 1, 4, 1, 5, 9, 2, 6, 5, 3;
    Sorter sorter(new BubbleSort());
    sorter.sort(nums);
    for (int num : nums) 
        std::cout << num << " ";
    
    std::cout << std::endl;

    sorter.setStrategy(new QuickSort());
    sorter.sort(nums);
    for (int num : nums) 
        std::cout << num << " ";
    
    std::cout << std::endl;

    return 0;

C++ 设计模式 —— 策略模式（Strategy）

策略模式是一种行为型设计模式（behavioral pattern），用于将不同的算法（算法之间的关系是平行的，也即，它们可以解决相同的问题，只不过采取了不同的策略，比如用于聚类的 Kmeans，FCM之间）封装在不同的类中，也即策略模式用于组织解决同一问题不同算法，以方便客户端（也即是下文的 Context 类）灵活地调用。最终得到算法的替换、变化可以独立于客户端完成。

其 UML 类图关系如下：

class Strategy
{
public:
    virtual ~Strategy(){}
    virtual void exec() = 0;
};

class StrategyA :public Strategy
{
public:
    void exec()
    {
        cout << "StrategyA::exec()" << endl;
    }
};

class StrategyB :public Strategy
{
public:
    void exec()
    {
        cout << "StrategyB::exec()" << endl;
    }
};

class Context
{
public:
    explicit Context(Strategy* strategy):_strategy(strategy)
    {}
    void set_strategy(Strategy* strategy)
    { _strategy = strategy; }
    void exec()
    { _strategy->exec();}
private:
    Strategy* _strategy;    
};

我们再来看客户端的调用情况：

int main(int, char**)
{
    StrategyA sa;
    StrategyB sb;

    Context ca(&sa);
    Context cb(&sb);
    ca.exec();
    cb.exec();
    cout << "=========================" << endl;
    ca.set_strategy(&sb);
    cb.set_strategy(&sa);
                            // 客户端，也即Context对象，可十分方便的切换切换自己的算法
    ca.exec();
    cb.exec();
    return 0;
}

最终的运行结果是：

StrategyA::exec()
StrategyB::exec()
=========================
StrategyB::exec()
StrategyA::exec()