策略模式

#include<iostream>
using namespace std;

//策略基类
class COperation
{
public:
	COperation(int a,int b):m_nFirst(a),m_nSecond(b){cout<<"1 constructed!\n";}
	virtual ~COperation(){cout<<"1 destructed!\n";};
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
protected:
	int m_nFirst;
	int m_nSecond;
};

//策略具体类—加法类
class AddOperation : public COperation
{
public:
	AddOperation(int a,int b):COperation(a,b){cout<<"+ constructed!\n";}
	double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
	 ~AddOperation(){cout<<"+ destructed!\n";};
};

//策略具体类—减法类
class SubtractOperation : public COperation
{
public:
	SubtractOperation(int a,int b):COperation(a,b){cout<<"- constructed!\n";}
	double GetResult()
	{
		return m_nFirst-m_nSecond;
	}
	 ~SubtractOperation(){cout<<"- destructed!\n";};
};


//策略具体类—乘法类
class MultiplicationOperation : public COperation
{
public:
	MultiplicationOperation(int a,int b):COperation(a,b){cout<<"* constructed!\n";}
	double GetResult()
	{
		return m_nFirst*m_nSecond;
	}
	 ~MultiplicationOperation(){cout<<"* destructed!\n";};
};

//策略具体类—除法类
class DivisionOperation : public COperation
{
public:
	DivisionOperation(int a,int b):COperation(a,b){cout<<"/ constructed!\n";}
	double GetResult()
	{
		return 1.0*m_nFirst/m_nSecond;
	}
	 ~DivisionOperation(){cout<<"/ destructed!\n";};
};


class Context
{
private:
	COperation* op;
public:
	Context(COperation *temp):op(temp){}
	double GetResult()
	{
		return op->GetResult();
	}
	virtual ~Context(){cout<<"context destructed!\n";}
};

//客户端
int main()
{
	int a,b;
    char c;
    cin>>a>>b;
	cout<<"请输入运算符:";
    cin>>c;
	Context *context;
	COperation *operation;
    switch(c){
		case '+':
			operation=new AddOperation(a,b);	
			break;
		case '-':
			operation=new SubtractOperation(a,b);
			break;
		case '*':
			operation=new MultiplicationOperation(a,b);
			break;
		case '/':
			operation=new DivisionOperation(a,b);
			break;
	}
	context=new Context(operation);
	cout<<context->GetResult()<<endl;
	delete operation;
	delete context;
	return 0;
}

HeadFirst 设计模式之策略模式

#include<iostream>
using namespace std;

/*封装飞行行为*/
class FlyBehavior{
public:
	virtual void fly(){}
};

class FlyWithWings:public FlyBehavior
{
public:
	void fly()
	{
		cout<<"I'm flying!"<<endl;
	}
};

class FlyNoWay:public FlyBehavior{
public:
	void fly()
	{
		cout<<"I can't fly!"<<endl;
	}
};

class FlyRocketPowered:public FlyBehavior{
public:
	void fly()
	{
		cout<<"I am flying with a rocket!"<<endl;
	}
};

/*封装呱呱叫行为*/
class QuackBehavior{
public:
	virtual void quack(){}
};

class Quack:public QuackBehavior{
public:
	void quack()
	{
		cout<<"Quack!"<<endl;
	}
};

class MuteQuack:public QuackBehavior
{
public:
	void quack()
	{
		cout<<"Silence!"<<endl;
	}
};

class Squeak:public QuackBehavior{
public:
	void quack()
	{
		cout<<"Squeak!"<<endl;
	}
};

/*客户*/
/*客户使用封装好的飞行和呱呱叫算法族*/
class Duck{
public:
	Duck(FlyBehavior *t1,QuackBehavior *t2):f(t1),q(t2){}
	void swim()
	{
		cout<<"All ducks float,even decoys!"<<endl;
	}
	virtual void display(){}
	void performQuack()
	{
		q->quack();
	}
	void performFly()
	{
		f->fly();
	}
	void setFlyBehavior(FlyBehavior *t1)
	{
		f=t1;
	}
	void setQuackBehavior(QuackBehavior *t1)
	{
		q=t1;
	}
protected:
	FlyBehavior *f;
	QuackBehavior *q;
};

class MallardDuck:public Duck{
public:
	MallardDuck():Duck(new FlyWithWings(),new Quack()){}/*未释放delete，留作后续解决*/
	void display()
	{
		cout<<"I am a real Mallard duck!"<<endl;
	}
};

class ModelDuck:public Duck{
public:
	ModelDuck():Duck(new FlyNoWay(),new Quack()){}
	void display()
	{
		cout<<"I am a model duck!"<<endl;
	}
};

void print(Duck &d)
{
	d.performQuack();
	d.performFly();
	d.swim();
	d.display();
}


int main(){
	Duck *d1=new MallardDuck();
	print(*d1);
	delete d1;
	Duck *d2=new ModelDuck();
	//print(*d2);
	d2->performFly();
	d2->setFlyBehavior(new FlyRocketPowered());
	d2->performFly();
	delete d2;

	return 0;
}

设计原则：

1.找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

2.针对接口编程，而不是针对实现编程。

3.多用组合，少用继承。

将两个类结合起来使用，如同本例一般，这就是组合。这种做法和“继承”不同的地方在于，鸭子的行为不是继承来的，而是和适当的行为对象“组合”来的。

使用组合建立系统具有很大的弹性，不仅可将算法族封装成类，更可以“在运行时动态地改变行为”，只要组合的行为对象符合正确的接口标准即可。

策略模式的定义：定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于是用算法的客户。