设计模式（二）策略模式

（二）策略模式

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

       策略模式和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式。

       GOOD : 适合类中的成员以方法为主，算法经常变动；

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

       BUG:客户端要做出判断。

#include <iostream>
using namespace std;

//    策略模式
//　　   定义算法家族，分别封装起来，让它们之间可以互相替换，让算法变化，不会影响到使用算法的客户。
//       策略模式和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式。
//       GOOD : 适合类中的成员以方法为主，算法经常变动；
//		        简化了单元测试（因为每个算法都有自己的类，可以通过自己的接口单独测试）。
//       BUG:客户端要做出判断。

//策略基类
class COperation
{
public:
	double m_nFirst;
	double m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具体类—加法类
class AddOperation : public COperation
{
public:
	AddOperation(double a,double b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

//策略具体类—减法类
class SubOperation : public COperation
{
public:
	SubOperation(double a,double b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst-m_nSecond;
	}
};

//策略具体类—乘法类
class MulOperation : public COperation
{
public:
	MulOperation(double a,double b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst*m_nSecond;
	}
};

//策略具体类—除法类
class DivOperation : public COperation
{
public:
	DivOperation(double a,double b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst/m_nSecond;
	}
};
//上下文
class Context
{
private:
	COperation* op;
public:
    Context(COperation* temp)
	{
        op=temp;
	}
	double GetResult()
	{
		return op->GetResult();
	}
};

//客户端
int main()
{
	double a,b;
    char c;
	Context *context=NULL;
	while(cin>>a>>b>>c)
	{
		switch(c)
		{
		   case '+':
				context=new Context(new AddOperation(a,b));
				cout<<context->GetResult()<<endl;
				break;
		   case '-':
				context=new Context(new SubOperation(a,b));
				cout<<context->GetResult()<<endl;
				break;
		   case '*':
				context=new Context(new MulOperation(a,b));
				cout<<context->GetResult()<<endl;
				break;
		   case '/':
			   if(b==0)
			   {
				   cout<<"非法输入，请重新输入"<<endl;
				   continue;
			   }
				context=new Context(new DivOperation(a,b));
				cout<<context->GetResult()<<endl;
				break;
		}
	}
	return 0;
}

策略与简单工厂结合

GOOD:客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。

在上例基础上，修改下面内容

#include <iostream>
using namespace std;

//	策略与工厂结合
//	GOOD:客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。

//策略基类
class COperation
{
public:
	double m_nFirst;
	double m_nSecond;
	COperation(double a=0,double b=0)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具体类—加法类
class AddOperation : public COperation
{
public:
	AddOperation(double a,double b):COperation(a,b){}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

//策略具体类—减法类
class SubOperation : public COperation
{
public:
	SubOperation(double a,double b):COperation(a,b){}
	virtual double GetResult()
	{
		return m_nFirst-m_nSecond;
	}
};

//策略具体类—乘法类
class MulOperation : public COperation
{
public:
	MulOperation(double a,double b):COperation(a,b){}
	virtual double GetResult()
	{
		return m_nFirst*m_nSecond;
	}
};

//策略具体类—除法类
class DivOperation : public COperation
{
public:
	DivOperation(double a,double b):COperation(a,b){}
	virtual double GetResult()
	{
		return m_nFirst/m_nSecond;
	}
};

//上下文
class Context
{
private:
	COperation* op;
public:
    Context(double a,double b,char cType)
	{
        switch (cType)
        {
		   case '+':
			    op=new AddOperation(a,b);
				break;
		   case '-':
			    op=new SubOperation(a,b);
				break;
		   case '*':
			    op=new MulOperation(a,b);
				break;
		   case '/':
				op=new DivOperation(a,b);
				break;
			default:
			op=new COperation(a,b);
			break;
        }
	}
	double GetResult()
	{
		return op->GetResult();
	}
};

//客户端
int main()
{
	Context *con=NULL;
	double a,b;
	char c;
	while(cin>>a>>b>>c)
	{
		if(b==0)
		{
			cout<<"非法输入，请重新输入"<<endl;
			continue;
		}
		con=new Context(a,b,c);
		cout<<con->GetResult()<<endl;
	}
	return 0;
}