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

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

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

#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的构造函数，然后调用显示结果函数就可以的，这样的话封装度就比之前更加高一级了。

转载于:https://my.oschina.net/u/3433829/blog/881543