《大话设计模式》c++实现 之策略模式

一、UML图

 

二、概念

策略模式：他定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

 

三、优点

（1）策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，他可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

（2）策略模式的Strategy类曾是为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。

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

（4）策略模式就是用来封装算法的。

（5）只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

（6）简单工厂模式需要让客户端认识两个类，而策略模式和简单工厂模式结合的用法，客户端只需要认识一个类Context即可。

 四 与工厂模式的区别：

工厂模式用来选择分支，产生不同的产品，（类）

策略模式是针对算法的，不同的算法用不同的类

#include <iostream>
using namespace std;




// 抽象产品类
class Operation{
protected:
    double num1;
    double num2;
public:
    double get_n1(){
        return num1;
    }
    double get_n2(){
        return num2;
    }
    void set_n1(int num){
        num1 = num;
    }
    void set_n2(int num){
        num2 = num;
    }
    virtual double GetResult(){
        double result = 0;
        return result;
    }

};
//具体产品类
class OperationAdd :public Operation{
public:
    double GetResult(){
        double result = 0;
        result = num1 + num2;
        return result;
    }
};

//具体产品类
class OperationSub :public Operation{
public:
    double GetResult(){
        double result = 0;
        result = num1 - num2;
        return result;
    }
};

//具体产品类
class OperationMul :public Operation{
public:
    double GetResult(){
        double result = 0;
        result = num1 * num2;
        return result;
    }
};

//具体产品类
class OperationDiv :public Operation{
public:
    double GetResult(){
        double result = 0;
        if (num2 != 0)
            result = num1 / num2;
        return result;
    }
};
//工厂类

class OperationFactory{
public:
    Operation* createOperation(char type){
        Operation* oper = NULL;
        switch (type)
        {
        case '+':
            oper = new OperationAdd;
            break;
        case '-':
            oper = new OperationSub;
            break;
        case '*':
            oper = new OperationMul;
            break;
        case '/':
            oper = new OperationDiv;
            break;
        }
        return oper;
    }
};


//策略类  
class Context{
private:
    Operation* op_;
public:
    Context(char type){
        OperationFactory of;
        op_ = of.createOperation(type);
    }
    double executeOperation(double num1, double num2){
        op_->set_n1(num1);
        op_->set_n2(num2);
        return op_->GetResult();
    }
    
};

void main(){

    double res = 0;
    Context co = Context('+');
    res = co.executeOperation(5, 3);
    cout << res << endl;


    Context co2 = Context('-');
    res = co2.executeOperation(5, 3);
    cout << res << endl;



    system("pause");
}

参考：

http://www.runoob.com/design-pattern/strategy-pattern.html

https://blog.csdn.net/xiqingnian/article/details/41855391