1、command.h
#ifndef COMMAND_H
#define COMMAND_H
#include <iostream>
#include <list>
#include <algorithm>
using namespace std;
class Chef //厨师,具体命令的执行者
{
public:
Chef();
~Chef();
void MakeMutton();//做Mutton
void MakeChickenWing();//做ChickenWing
};
class Command //命令基类
{
protected:
Chef* receiver;
public:
Command(Chef* c);
~Command();
virtual void ExcuteCommand() = 0;
};
class MakeMuttonCommand : public Command //具体命令,继承命令基类,与厨师具体命令的执行者相联系
{
public:
MakeMuttonCommand(Chef* c);
virtual void ExcuteCommand();
};
class MakeChickenWingCommand : public Command 具体命令,继承命令基类,与厨师具体命令的执行者相联系
{
public:
MakeChickenWingCommand(Chef* c);
virtual void ExcuteCommand();
};
class Waiter //侍者、服务员,命令的接收者和协调者
{
private:
list<Command*> orders;
public:
Waiter();
~Waiter();
void AddOrder(Command* order);
void RemoveOrder(Command* order);
void NotifyExcute();
};
#endif // COMMAND_H
2、command.cpp
#include "command.h"
Chef::Chef(){}
Chef::~Chef(){}
void Chef::MakeChickenWing()
{
cout << " making ChickenWing" << endl;
}
void Chef::MakeMutton()
{
cout << " making Mutton" << endl;
}
Command::Command(Chef *c)
{
receiver = c;
}
Command::~Command(){}
MakeMuttonCommand::MakeMuttonCommand(Chef *c):Command(c){}
void MakeMuttonCommand::ExcuteCommand()
{
receiver->MakeMutton();
}
MakeChickenWingCommand::MakeChickenWingCommand(Chef *c):Command(c){}
void MakeChickenWingCommand::ExcuteCommand()
{
receiver->MakeChickenWing();
}
Waiter::Waiter(){}
Waiter::~Waiter(){}
void Waiter::AddOrder(Command *order)
{
cout << "Add order" << endl;
orders.push_back(order);
}
void Waiter::RemoveOrder(Command *order)
{
list<Command*>::iterator iter = find(orders.begin(), orders.end(), order);
if (iter != orders.end())
{
cout << "Remove order" << endl;
orders.erase(iter);
}
}
void Waiter::NotifyExcute()
{
for (list<Command*>::iterator iter = orders.begin(); iter != orders.end(); ++iter)
{
(*iter)->ExcuteCommand();
}
}
3、main.cpp
/*
作者:jhluroom弹 QQ:454676244 MSN:jhlu0815@hotmail.com
开发IDE:qt creater
开发环境:QT C++
参考网站:神秘果:http://www.shenmiguo.com/
定义:
命令模式(Command):将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;
对请求排队或记录请求日志,以及支持可撤销的操作。
理解:
1.客户只需要知道向Waiter发出命令(多个命令),而不是将命令直接传达给具体的执行者。
当然,客户是需要知道都有什么命令的。
2.客户只发命令,不需要知道由谁来执行和怎么执行,体现出高内聚的特点。
用户在发出命令后,是允许撤回的,所以还可以增加一个命令“Undo ”,Undo是状态的变更。
3.命令模式(Command)把请求封装成一个对象,使请求能够存储更多的信息拥有更多的能力。
命令模式同样能够把请求的发送者和接收者解耦,但它不关心请求将以何种方式被处理。
命令模式经常与职责链模式(Chain of Responsibility)和组合模式(Composite)一起使用,
职责链模式处理命令模式封装的对象,组合模式可以把简单的命令对象组合成复杂的命令对象。
要点:
1.是消除被调用函数的选择与那个函数被调用的位置之间的联系。
命令模式就是一个函数对象:一个作为对象的函数。通过将函数封装为对象,就能够以参数的形式将其传递给其他函数或者对象。
2.是允许向一个函数或者对象传递一个想要的动作。
命令模式的一个常见的例子就是在应用程序中“撤销操作”功能的实现。每次在用户进行某项操作的时候,
相应的“撤销操作”命令对象就被置入一个队列中,而每个命令对象被执行后,程序的状态就倒退一步。
应用:
厨师Chef可以做两个动作命令:MakeMutton和MakeChickenWing;服务员侍者Waiter负责命令的接收和协调;
用户Client可以创建多种命令,服务员Waiter负责将这些命令添加或删除形成一条队列。
用户Client调用服务员侍者Waiter执行些队列中的命令。
以上文字说明,从网上整理而来,有可能部分与其他同仁相同,请谅解,希望我们能够共同交流,谢谢!
*/
#include <QtCore/QCoreApplication>
#include "command.h"
int main(int argc, char *argv[])
{
cout << "=== jhluroom start ========" << endl;
Chef* chef = new Chef();
Command* makeMuttonCommand1 = new MakeMuttonCommand(chef);
Command* makeMuttonCommand2 = new MakeMuttonCommand(chef);
Command* makeChickenWingCommand1 = new MakeChickenWingCommand(chef);
Command* makeChickenWingCommand2 = new MakeChickenWingCommand(chef);
Waiter* waiter = new Waiter();
waiter->AddOrder(makeMuttonCommand1);
waiter->AddOrder(makeMuttonCommand2);
waiter->AddOrder(makeChickenWingCommand1);
waiter->AddOrder(makeChickenWingCommand2);
cout << endl <<"NotifyExcute for 1 is:" << endl;
waiter->NotifyExcute();
cout << endl;
waiter->RemoveOrder(makeMuttonCommand2);
waiter->RemoveOrder(makeChickenWingCommand2);
cout << endl << "NotifyExcute for 2 is:" << endl;
waiter->NotifyExcute();
cout << endl;
cout << "=== jhluroom finish _^_ ===" << endl;
return 0;
}
运行结果:
=== jhluroom start ========
Add order
Add order
Add order
Add order
NotifyExcute for 1 is:
making Mutton
making Mutton
making ChickenWing
making ChickenWing
Remove order
Remove order
NotifyExcute for 2 is:
making Mutton
making ChickenWing
=== jhluroom finish _^_ ===