策略模式——C++实现

策略模式其实和简单工厂模式很相似,在看《大话设计模式》这本书时,一开始也是一度弄混这两个模式,关于简单工厂模式的一个介绍以及C++代码可以参考上一篇文章点击打开链接。策略模式和简单工厂模式最主要的区别在于客户端用户需要操作几个类,下面仍以加、减、乘、除计算来讲解:


在上简单工厂模式中,客户端代码:

int main()  
  
{      
    double A, B;  
      
    char ch;  
      
    while (cin >> A >> ch >> B){  
          
        operation *op = factory::createOperator(ch);          //产生实例  
          
        op->setA(A);       //动态绑定  
          
        op->setB(B);           //动态绑定  
          
        cout << op->getResult() << endl;     //动态绑定  
          
    }     
}  

策略模式中客户端代码:

int main()

{
    
    double A, B;
    
    char ch;
    
    while (cin >> A >> ch >> B){
        
        factory::createOperator(ch);
        
        cout<<factory::result(A,B)<<endl;
        
    }
    
}

从上述两个客户端代码可见:简单工厂模式中,使用者需要操作factory、operation这两个类;策略模式中,使用者只需要操作factory这个类。这就是简单工厂模式和策略模式最主要的区别(至于为什么要这样,应该是根据不同的应用场景和需求来决定的吧,但是因为自己对实际应用场景了解太少,这里就不胡乱写了,只从理论上说说二者区别)

至于怎么实现在策略模式中只操作一个类,其实很简单,只需要修改工厂类factory,而不需要修改operation类及其子类,如下:

简单工厂模式的factory类:

class factory{  
      
public:  
      
    factory(){ };  
      
    ~factory(){ };  
      
    static operation* createOperator(char c){  
          
        operation* op = NULL;     //基类指针  
          
        switch (c){  
                  
            case '+':  
                  
                op = new Add();  
                  
                break;  
                  
            case '-':  
                  
                op = new Sub();  
                  
                break;  
                  
            case '*':  
                  
                op = new Mul();  
                  
                break;  
                  
            case '/':  
                  
                op = new Div();  
                  
                break;  
                  
            default:  
                  
                break;  
                  
        }  
          
        return op;         
    }      
};  

策略模式的factory类;

class factory{
    
public:
    
    factory(){
        
    };
    
    ~factory(){
        
    };
 
    static void createOperator(char c){
        
        switch (c){
                
            case '+':
                
                op = new Add();
                
                break;
                
            case '-':
                
                op = new Sub();
                
                break;
                
            case '*':
                
                op = new Mul();
                
                break;
                
            case '/':
                
                op = new Div();
                
                break;
                
            default:
                
                break;
                
        }
        
    }
    
    static double result(double A, double B){
        
        op->setA(A);
        
        op->setB(B);
        
        return op->getResult();
    }
    
private:
    
    static operation* op;      //基类指针
    
};

从上述两端代码可以看到,策略模式将对operation类的相关操作放到了factory类中,进而,策略模式下的客户端只需要操作factory一个类即可。换言之,factory类中既要有一个函数负责产生operation类的实例,又要有一个函数来调用operation类中对应的方法,比如:

static double result(double A, double B){
        
        op->setA(A);
        
        op->setB(B);
        
        return op->getResult(); //调用operation类的getResult方法
    }

策略模式下加减乘除运算整体C++代码:

#include<iostream>

using namespace std;

class operation {
    
public:
    
    operation():A(0),B(0){
        
    }
    
    virtual ~operation(){
        
    }
    
    void setA(double x){
        
        A = x;
        
    }
    
    void setB(double y){
        
        B = y;
        
    }
    
    double getA(){
        
        return A;
        
    }
    
    double getB(){
        
        return B;
        
    }
    
    virtual double getResult() = 0;  //纯虚函数
    
private:
    
    double A;
    
    double B;
    
    char ch;
    
};

class Add :public operation {
    
public:
    
    double getResult(){
        
        return getA() + getB();
        
    }
    
};

class Sub :public operation {
    
public:
    
    double getResult(){
        
        return getA() - getB();
        
    }
    
};

class Mul : public operation{
    
public:
    
    double getResult(){
        
        return getA()*getB();
        
    }
    
};

class Div :public operation{
    
public:
    
    double getResult(){
        
        if (getB() == 0){
            
            cout << "input error" << endl;
            
            return -1;
            
        }
        
        else return getA() / getB();
        
    }
    
};

class factory{
    
public:
    
    factory(){
        
    };
    
    ~factory(){
        
    };
 
    static void createOperator(char c){
        
        switch (c){
                
            case '+':
                
                op = new Add();
                
                break;
                
            case '-':
                
                op = new Sub();
                
                break;
                
            case '*':
                
                op = new Mul();
                
                break;
                
            case '/':
                
                op = new Div();
                
                break;
                
            default:
                
                break;
                
        }
        
    }
    
    static double result(double A, double B){
        
        op->setA(A);
        
        op->setB(B);
        
        return op->getResult();
    }
    
private:
    
    static operation* op;      //基类指针
    
};

operation* factory::op=NULL;

int main()

{
    
    double A, B;
    
    char ch;
    
    while (cin >> A >> ch >> B){
        
        factory::createOperator(ch);
        
        cout<<factory::result(A,B)<<endl;
        
    }
    
}

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_39138071/article/details/80351131
个人分类: 设计模式
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

策略模式——C++实现

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭