设计模式之策略模式

窝在看<stl源码剖析>的时候，看到了策略模式，我觉得挺有意思的，
策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

在这里我设计了两个具体的动作，一个是唱歌，一个是跳舞。 然后将其的动作函数**Sing()和Dance()**设置成纯虚函数。

然后具体的动作分别去继承他们

class WithSing :public RobotSingBehavior

class WithoutSing : public RobotSingBehavior

class WithDance : public RobotDanceBehavior

class WithoutDance :public RobotDanceBehavior

然后申明一个Robot的基类，然后在它的派生类中用具体的动作去填充。
详情见代码：

#include "stdafx.h"
#include<iostream>
using namespace std;


//机器人跳舞的动作
class RobotSingBehavior
{
public:
	virtual ~RobotSingBehavior(){};
	virtual void  Sing() = 0; 
};


//机器人唱歌的动作
class RobotDanceBehavior
{
public:
	virtual ~RobotDanceBehavior(){};
	virtual void Dance() = 0;
};


class Robot
{
public:
	Robot(RobotSingBehavior* RobotSing, RobotDanceBehavior* RobotDance)
	{
		pRobotSing = RobotSing;
		pRobotDance = RobotDance;
	}
	virtual ~Robot(){}
	
	void performSing()
	{
		pRobotSing->Sing();
	}

	void performDance()
	{
		pRobotDance->Dance();
	}

	virtual void Display() {}

private:
	RobotSingBehavior*  pRobotSing;
	RobotDanceBehavior* pRobotDance;
};



class WithSing :public RobotSingBehavior
{
	void Sing()
	{
		cout << "i can sing" << endl;
	}
};

class WithoutSing : public RobotSingBehavior
{
	void Sing()
	{
		cout << "i can not sing" << endl;
	}
};

class WithDance : public RobotDanceBehavior
{
	void Dance()
	{
		cout << "i can Dance" << endl; 
	}
};


class WithoutDance :public RobotDanceBehavior
{
	void Dance()
	{
		cout << "i can not Dance" << endl;
	}
};

//会唱歌但是不会跳舞的机器人
class Robot1 :public Robot
{
public:
	Robot1(RobotSingBehavior*  RobotSing = new WithSing(), RobotDanceBehavior* RobotDance = new WithoutDance()) 
	:Robot(RobotSing,RobotDance){}
	

	void Display()
	{
		cout << " i am a robot can sing but not dance " << endl;
	}
};



int main()
{
	
	Robot* pRobot1 = new Robot1();
	pRobot1->performSing(); 
	pRobot1->performDance();

	return 0;
}

运行结果 ：