C++之策略模式实现

这里沿用《大话设计模式》第二章2.4的代码，对其略作修改。

代码值得注意的是，1. 为了能实现多态，Context类中Strategy* strategy，为指针

                               2. 由于本题为简单程序，动态申请的内存可以手动释放。因为程序结束自然释放。

 

//策略模式

#include <iostream>
using namespace std;

//含有纯虚函数的类，为虚基类。为了Context类的建立，放弃使用虚基类
class Strategy{
public:
    virtual void AlgorithmInterface(){   
       
    }
};

class ConcreteStrategyA :public Strategy{
public:
    void AlgorithmInterface() override{
        cout << "算法A实现" << endl;
    }
};

class ConcreteStrategyB :public Strategy{
public:
    void AlgorithmInterface() override{
        cout << "算法B实现" << endl;
    }
};

class ConcreteStrategyC :public Strategy{
public:
    void AlgorithmInterface() override{
        cout << "算法C实现" << endl;
    }
};

class Context{
private:
    Strategy* strategy;

public:
    Context(Strategy* strategy){
        this->strategy = strategy;
    }

    void ContextInterface(){
        cout << 1 << endl;
        strategy->AlgorithmInterface();
    }
};

int main(){
    Context* context;

    context = new Context(&ConcreteStrategyA());
    context->ContextInterface();

    context = new Context(&ConcreteStrategyB());
    context->ContextInterface();

    context = new Context(&ConcreteStrategyC());
    context->ContextInterface();

    return 0;
}

 

与简单工厂模式的结合实现。这里为什么没有单独讲简单工厂模式呢，因为它往往与策略模式结合在一起。

#include <iostream>
using namespace std;

//含有纯虚函数的类，为虚基类
class Strategy{
public:
    virtual void AlgorithmInterface(){
        cout << " Jilei" << endl;
    }
};

class ConcreteStrategyA :public Strategy{
public:
    void AlgorithmInterface() override{
        cout << "算法A实现" << endl;
    }
};

class ConcreteStrategyB :public Strategy{
public:
    void AlgorithmInterface() override{
        cout << "算法B实现" << endl;
    }
};

class ConcreteStrategyC :public Strategy{
public:
    void AlgorithmInterface() override{
        cout << "算法C实现" << endl;
    }
};

//结合简单工厂模式对其进行修改
class Context{
public:
    Strategy* strategy = nullptr;

    Context(char a){
        switch (a)
        {
        case 'A':
            this->strategy = new ConcreteStrategyA();
            break;
        case 'B':
            this->strategy = new ConcreteStrategyB();
            break;
        case 'C':
            this->strategy = new ConcreteStrategyC();
            break;
        }
    }

    void ContexInterface(){
        this->strategy->AlgorithmInterface();
    }
};

int main(){
    char a;
    cin >> a;

    Context context(a);
    context.ContexInterface();

    
    return 0;
}

 

从以上可以看出优点：（业务逻辑与界面逻辑分离的体现）

  1.策略模式是一种定义一系列算法的方法，从概念上来看，所有这种算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法减少了各种算法类与使用算法类之间的耦合。同时更好的体现了“封装性”。

  2.策略模式的Strategy类（抽象类）层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取这些算法中的公共功能。

  3.简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

  4.策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

  5.将这些业务规则封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。

缺点：（简单工厂模式同有）

    增加新的业务规则，代码更改量大。即，需要增加新的Strategy派生类，同时，还要在switch结构中做更改。（反射技术可以解决）