策略模式--行为模式

1、描述

策略是一种行为设计模式，它让你定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。

优点：1、算法可以自由切换； 2、避免使用多重条件判断； 3、扩展性良好

缺点：1、策略类数量增多； 2、所有的策略类都需要对外暴露

2、结构图

• 上下文（Context）维护指向具体策略的引用，且仅通过策略接口与该对象进行交流。
• 策略（Strategy）接口是所有具体策略的通用接口，它声明了一个上下文用于执行策略的方法。
• 具体策略（Concrete Strategies）实现了上下文所用算法的各种不同变体。
• 当上下文需要运行算法时，它会在其已连接的策略对象上调用执行方法。上下文不清楚其所涉及的策略类型与算法的执行方式。

3、C++程序

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

//策略抽象类声明了所有具体算法需要支持的通用操作
class Strategy
{
public:
    virtual ~Strategy() {}
    virtual std::string DoAlgorithm(const std::vector<std::string> &data) const = 0;
};

//Context定义了客户感兴趣的接口
class Context
{
private:
    //Context维护一个策略抽象类对象的指针，Context并不知道其是什么具体策略类。Context通过
    //策略抽象类声明的一般接口调用具体策略类
    Strategy *strategy_;

public:
    Context(Strategy *strategy = nullptr) : strategy_(strategy)
    {
    }
    ~Context()
    {
        delete this->strategy_;
    }

    //通常，Context允许在运行时替换策略对象
    void set_strategy(Strategy *strategy)
    {
        delete this->strategy_;
        this->strategy_ = strategy;
    }

    //Context将任务分派给策略类，而不是自己实现。
    void DoSomeBusinessLogic() const
    {
        // ...
        std::cout << "Context: Sorting data using the strategy (not sure how it'll do it)\n";
        std::string result = this->strategy_->DoAlgorithm(std::vector<std::string>{"a", "e", "c", "b", "d"});
        std::cout << result << "\n";
        // ...
    }
};

//具体的策略类实现了抽象策略类声明的接口。
class ConcreteStrategyA : public Strategy
{
public:
    std::string DoAlgorithm(const std::vector<std::string> &data) const override
    {
        std::string result;
        std::for_each(std::begin(data), std::end(data), [&result](const std::string &letter) {
            result += letter;
        });
        std::sort(std::begin(result), std::end(result));

        return result;
    }
};
class ConcreteStrategyB : public Strategy
{
    std::string DoAlgorithm(const std::vector<std::string> &data) const override
    {
        std::string result;
        std::for_each(std::begin(data), std::end(data), [&result](const std::string &letter) {
            result += letter;
        });
        std::sort(std::begin(result), std::end(result));
        for (int i = 0; i < result.size() / 2; i++)
        {
            std::swap(result[i], result[result.size() - i - 1]);
        }

        return result;
    }
};

//客户选择一个具体的策略类传给Context。为了做出正确地选择，客户应该知道这些策略的不同之处。
void ClientCode()
{
    Context *context = new Context(new ConcreteStrategyA);
    std::cout << "Client: Strategy is set to normal sorting.\n";
    context->DoSomeBusinessLogic();
    std::cout << "\n";
    std::cout << "Client: Strategy is set to reverse sorting.\n";
    context->set_strategy(new ConcreteStrategyB);
    context->DoSomeBusinessLogic();
    delete context;
}

int main()
{
    ClientCode();
    return 0;
}

参考

https://refactoringguru.cn/