设计模式学习--策略模式

谁借莪１个温暖的怀抱￠ 2022-09-27 04:54 153阅读 0赞

看完了策略模式的讲解，然后将之于之前的简单工厂模式对比了一下，策略模式就是将具体的算法变化封装了一下，可以将两者结合一起使用，这样的话封装度会更加高一点，而且在更改算法和添加算法的时候更加方便。

《大话设计模式》书中是用商场收银做例子，我将之用简单工厂模式做了之后，现在把之前的计算例子再拿出来给一下，这个例子比较小，看起来比较明了。

![SouthEast][]

#include <iostream>
    #include <string> 
    #include <exception>
    
    using namespace std;
    
    class Operate									//算法类基类
    {
    	double NumberA;								//操作数NumberA
    	double NumberB;								//操作数NumberB
    public:
    	void setNumA(double A){NumberA = A;}		//NumberA赋值
    	void setNumB(double B){NumberB = B;}		//NumberB赋值
    	double getNumA(){return NumberA;}			//获取NumberA值
    	double getNumB(){return NumberB;}  			//获取NumberB值
    	virtual double getresult()					//虚函数  用于实现多态  实现派生类的getresult()函数		
    	{
    		double result;
    		return result;
    	}  
    };
    
    class OperateADD : public Operate				//加法算法类
    {
    	double getresult()
    	{
    		double result;
    		double numA = this->getNumA(); 
    		double numB = this->getNumB();
    		result = numA + numB;
    		return result;
    	} 
    }; 
    
    class OperateSUB : public Operate				//减法算法类
    {
    	double getresult()
    	{
    		double result;
    		double numA = this->getNumA(); 
    		double numB = this->getNumB();
    		result = numA - numB;
    		return result;
    	}
    };
    
    class OperateMUL : public Operate				//乘法算法类
    {
    	double getresult()
    	{
    		double result;
    		double numA = this->getNumA(); 
    		double numB = this->getNumB();
    		result = numA * numB;
    		return result;
    	}
    };
    
    class OperateDIV : public Operate				//除法算法类
    {
    	double getresult()
    	{
    		double result;
    		double numA = this->getNumA();
    		double numB = this->getNumB();
    		try
    		{
    			if(numB == 0)						//除数为0时 抛出异常
    			{
    				throw "除数不能为0！";
    			}
    			else
    			{
    				result = numA / numB;
    				return numB;
    			}
    		}	
    		catch(const char* msg)
    		{
    			cout<<msg<<endl;
    		}
    	}
    };
    
    class OperaContext
    {
    	Operate *oper;														//声明一个算法类指针
    public:
    	OperaContext(char operate, double num1, double num2)				//将运算符和操作数传入构造函数
    	{
    		switch(operate)													//由运算符定义实例
    		{
    			case '+':
    			{
    				oper = new OperateADD;
    				break;
    			} 
    			case '-':
    			{
    				oper = new OperateSUB;
    				break;
    			}
    			case '*':
    			{
    				oper = new OperateMUL;
    				break;
    			}
    			case '/':
    			{
    				oper = new OperateDIV;
    				break;
    			}
    		} 
    		oper->setNumA(num1);												//将操作数传入算法类基类
    		oper->setNumB(num2);												//将操作数传入算法类基类
    	} 
    	double Getresult()														//将结果输出
    	{
    		return oper->getresult();
    	}
    };
    
    int main()
    {
    	try
    	{
    		double numA, numB;
    		char ope;
    		cout<<"请输入数字A：";
    		cin>>numA;
    		cout<<"请输入运算符(+、-、*、/):";
    		cin>>ope;
    		cout<<"请输入数字B：";
    		cin>>numB;
    		
    		OperaContext OFT(ope, numA, numB);									//定义实例
    		// OperatorFactory OFT;
    		// Operate *my_oper = OFT.operatorcreate(ope);
    		// my_oper->setNumA(numA);
    		// my_oper->setNumB(numB);	
    		cout<<"结果为："<<OFT.Getresult()<<endl;							//输出结果
    	}	
    	catch(exception &e)
    	{
    		cout<<"您的输入有误！"<<endl;
    	}
    	
    	return 0;
    }

简单工厂模式做的时候，客户端需要认识两个类工厂类OperatorFactory类和算法基类Operate类，而用简单工厂模式和策略模式共用的时候，客户端只需要认识一个类OperaContext类，只需将运算符和操作数传入OperaContext的构造函数，然后调用显示结果函数就可以的，这样的话封装度就比之前更加高一级了。

[SouthEast]: /images/20220708/77a8ba606a1949da99d26c28e565e985.png