：命令模式：Command

#ifndef __COMMAND_H__
#define __COMMAND_H__
#include <vector>
#include "Equipment.h"

class Command
{
public:
	Command(){}
	virtual ~Command(){}
	virtual void Execute(){}
	virtual void Undo(){}
};

class NoCommand :public Command
{
public:
	NoCommand(){}
	virtual ~NoCommand(){}
	virtual void Execute()
	{
		print("No Command Execute");
	}
	virtual void Undo()
	{
		print("No Command Undo");
	}
};

class LightOnCommand : public Command
{
private:
	Light *light;
public:
	LightOnCommand(Light *l)
	{
		light = l;
	}
	virtual ~LightOnCommand(){}
	virtual void Execute()
	{
		light->On();
	}
	virtual void Undo()
	{
		light->Off();
	}
};

class LightOffCommand : public Command
{
private:
	Light *light;
public:
	LightOffCommand(Light *l)
	{
		light = l;
	}
	virtual ~LightOffCommand(){}
	virtual void Execute()
	{
		light->Off();
	}
	virtual void Undo()
	{
		light->On();
	}
};

class GarageDoorUpCommand : public Command
{
private:
	GarageDoor *door;
public:
	GarageDoorUpCommand(GarageDoor *d)
	{
		door = d;
	}
	virtual ~GarageDoorUpCommand(){}
	virtual void Execute(){door->up();}
	virtual void Undo(){ door->down(); }
};

class GarageDoorDownCommand : public Command
{
private:
	GarageDoor *door;
public:
	GarageDoorDownCommand(GarageDoor *d){	door = d;}
	virtual ~GarageDoorDownCommand(){}
	virtual void Execute(){ door->down(); }
	virtual void Undo(){ door->up(); }
};

class PartyBeginCommand : public Command
{
private:
	vector<Command *>commands;
public:
	PartyBeginCommand(vector<Command *> cmd)
	{
		commands.swap(cmd);
	}

	virtual void Execute()
	{
		for (size_t i = 0; i < commands.size(); i++)
		{
			commands[i]->Execute();
		}
	}

	virtual void Undo()
	{
		for (size_t i = 0; i < commands.size(); i++)
		{
			commands[i]->Undo();
		}
	}

};

#endif

#ifndef __EQUIPMENT_H__
#define __EQUIPMENT_H__
#include <iostream>
using namespace std;
void print(const char *p)
{
	cout << p << endl;
}

class Light
{
public:
	Light(){}
	~Light(){}
	void On(){print("Light On");}
	void Off(){print("Light Off");}
};

class GarageDoor
{
public:
	GarageDoor(){}
	~GarageDoor(){}
	void up(){ print("GarageDoor Up"); }
	void down(){ print("GarageDoor Down"); }
	void stop(){ print("GarageDoor Stop"); }
};

#endif

#ifndef __CONTROL_H__
#define __CONTROL_H__
#include "Command.h"
class SimpleRemoteControl
{
private:
	Command * command;
public:
	SimpleRemoteControl(){}
	virtual ~SimpleRemoteControl(){}
	void setCommand(Command *c)
	{
		command = c;
	}

	void ButtonPressed()
	{
		command->Execute();
	}
};

class RemoteControl
{
private:
	Command * onCommand[7];
	Command * offCommand[7];
	NoCommand *ncommand;
	Command *preCommand;
public:
	RemoteControl()
	{
		ncommand = new NoCommand();
		for (int i = 0; i < 7; i++)
		{
			onCommand[i] = ncommand;
			offCommand[i] = ncommand;
		}
	}
	~RemoteControl()
	{
		delete ncommand;
	}
	void SetCommand(int i, Command *on, Command *off)
	{
		onCommand[i] = on;
		offCommand[i] = off;
	}

	void OnButtonPress(int i)
	{
		onCommand[i]->Execute();
		preCommand = onCommand[i];
	}

	void OffButtonPress(int i)
	{
		offCommand[i]->Execute();
		preCommand = offCommand[i];
	}
	void UndoButtonPress()
	{
		preCommand->Undo();
	}

};
#endif

#include "Control.h"
using namespace std;

int main()
{
	Light *light = new Light();
	GarageDoor *gdoor = new GarageDoor();
	SimpleRemoteControl *rc = new SimpleRemoteControl();

	Command *lightoncommand = new LightOnCommand(light);
	Command *lightoffcommand = new LightOffCommand(light);
	Command *gdoordown = new GarageDoorDownCommand(gdoor);
	Command *gdoorup = new GarageDoorUpCommand(gdoor);

	print("===Now is SimpleRemoteControl===");
	rc->setCommand(lightoncommand);
	rc->ButtonPressed();
	rc->setCommand(lightoffcommand);
	rc->ButtonPressed();
	rc->setCommand(gdoorup);
	rc->ButtonPressed();
	rc->setCommand(gdoordown);
	rc->ButtonPressed();

	print("===Now is RemoteControl===");
	RemoteControl *control = new RemoteControl();
	vector<Command*>ptyBegin = { gdoorup, lightoncommand };

	vector<Command*>ptyend = { lightoffcommand,gdoordown };

	Command *pbegin = new PartyBeginCommand(ptyBegin);
	Command *pend = new PartyBeginCommand(ptyend);

	control->SetCommand(0, lightoncommand, lightoffcommand);
	control->SetCommand(1, gdoorup, gdoordown);
	control->SetCommand(2, pbegin, pend);
 	control->OnButtonPress(0);
  	control->OffButtonPress(0);
  	control->OnButtonPress(1);
  	control->OffButtonPress(1);
	print("---Undo---");
	control->UndoButtonPress();

	control->OnButtonPress(2);
	control->OffButtonPress(2);
	print("---Undo---");
	control->UndoButtonPress();

	return 0;
}