C++命令模式（Command）

UML类图（仅供参考）如下：

命令模式解决的问题：

在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令

源码

#include <iostream>
#include <string>
#include <list>

// 烧烤厨师
class CBarbecuer
{
public:

	// 厨师的一个功能为烤羊肉串
	void BakeMutton()
	{
		std::cout << "烧烤厨师:我正在烤一串羊肉串:" << std::endl;
	}

	// 厨师的一个功能为烤鸡翅
	void BakeChickenWing()
	{
		std::cout << "烧烤厨师:我正在烤一个鸡翅:" << std::endl;
	}
};

// 抽象命令类,控制厨师到底烤什么肉
class CCommand
{
public:
	// 确定执行烤肉的厨师
	CCommand(CBarbecuer *pcBarbecuer) :m_pcBarbecuer(pcBarbecuer) {}
	virtual ~CCommand() {}
	virtual void ExcuteCommand() = 0;
	std::string& GetCmdStr()
	{
		return m_sCmd;
	}

protected:

	CBarbecuer *m_pcBarbecuer;

	// 命令描述,确定厨师到底烤什么肉
	std::string m_sCmd;
};

// 烤羊肉串命令类
class CBakeMutton :public CCommand
{
public:
	CBakeMutton(CBarbecuer *pcBarbecuer) :CCommand(pcBarbecuer) 
	{
		// 给厨师设置命令为考羊肉串
		m_sCmd = "BakeMutton";
	}
	void ExcuteCommand()
	{
		m_pcBarbecuer->BakeMutton();
	}
};

// 烤鸡翅命令类
class CBakeChickenWing :public CCommand
{
public:
	CBakeChickenWing(CBarbecuer *pcBarbecuer) :CCommand(pcBarbecuer) 
	{
		// 给厨师设置命令为考鸡翅
		m_sCmd = "BakeChickenWing";
	}
	void ExcuteCommand()
	{
		m_pcBarbecuer->BakeChickenWing();
	}
};

// 服务员类
class CWaiter
{
public:
	CWaiter() :m_listCmd(new std::list<CCommand*>()) {}

	// 添加一个命令
	void SetOrder(CCommand *pcCommand)
	{
		if ("BakeMutton" == pcCommand->GetCmdStr())
		{
			if (m_iAlreadyMuttoCount >= m_iMuttoCount)
			{
				std::cout << "服务员:羊肉串已经没有了" << std::endl;
			}
			else
			{
				// 修改类成员,本来是要加锁的,这里暂时不处理
				++m_iAlreadyMuttoCount;
				std::cout << "服务员:增加一串烤羊肉串" << std::endl;
				m_listCmd->push_back(pcCommand);
			}
		}
		else if("BakeChickenWing" == pcCommand->GetCmdStr())
		{
			if (m_iAlreadyChickenWing >= m_iChickenWing)
			{
				std::cout << "服务员:鸡翅已经没有了" << std::endl;
			}
			else
			{
				// 修改类成员,本来是要加锁的,这里暂时不处理
				++m_iAlreadyChickenWing;
				std::cout << "服务员:增加一个鸡翅" << std::endl;
				m_listCmd->push_back(pcCommand);
			}
		}
		else
		{

		}
	}

	void CancelOrder(CCommand *pcCommand)
	{
		auto it = std::find(m_listCmd->begin(), m_listCmd->end(), pcCommand);
		if (it != m_listCmd->end())
		{
			if ("BakeMutton" == pcCommand->GetCmdStr())
			{
				// 修改类成员,本来是要加锁的,这里暂时不处理
				--m_iAlreadyMuttoCount;
				std::cout << "服务员:取消一串羊肉串" << std::endl;
			}
			else if ("BakeChickenWing" == pcCommand->GetCmdStr())
			{
				// 修改类成员,本来是要加锁的,这里暂时不处理
				--m_iAlreadyChickenWing;
				std::cout << "服务员:取消一个鸡翅" << std::endl;
			}
			else
			{

			}
			m_listCmd->erase(it);
		}
	}

	void Notify()
	{
		for (CCommand* var : *m_listCmd)
		{
			var->ExcuteCommand();
		}
	}

private:
	// 记录客人要点的才(命令链表)
	std::list<CCommand*> *m_listCmd;

	// 羊肉串总个数
	const int m_iMuttoCount = 3;

	// 鸡翅总个数
	const int m_iChickenWing = 4;

	// 当前所有的客人已经点了多少羊肉串
	static int m_iAlreadyMuttoCount;

	// 当前所有的客人已经点了多少鸡翅
	static int m_iAlreadyChickenWing;
};
int CWaiter::m_iAlreadyMuttoCount = 0;
int CWaiter::m_iAlreadyChickenWing = 0;

int main()
{
	// 烧烤店开张前得有一个厨师
	CBarbecuer *pBarbecuer = new CBarbecuer();

	// 烧烤店开张前得有一个服务员
	CWaiter *pWaiter = new CWaiter();

	// 客人选择烧烤(创建命令)
	CCommand *bakeMutton1 = new CBakeMutton(pBarbecuer);
	CCommand *bakeMutton2 = new CBakeMutton(pBarbecuer);
	CCommand *bakeMutton3 = new CBakeMutton(pBarbecuer);
	CCommand *bakeMutton4 = new CBakeMutton(pBarbecuer);
	CCommand *bakeChickenWing1 = new CBakeChickenWing(pBarbecuer);
	CCommand *bakeChickenWing2 = new CBakeChickenWing(pBarbecuer);
	CCommand *bakeChickenWing3 = new CBakeChickenWing(pBarbecuer);
	CCommand *bakeChickenWing4 = new CBakeChickenWing(pBarbecuer);
	CCommand *bakeChickenWing5 = new CBakeChickenWing(pBarbecuer);
	CCommand *bakeChickenWing6 = new CBakeChickenWing(pBarbecuer);

	// 客人向服务员点烧烤(添加命令)
	pWaiter->SetOrder(bakeMutton1);
	pWaiter->SetOrder(bakeMutton2);
	pWaiter->SetOrder(bakeMutton3);
	pWaiter->SetOrder(bakeMutton4);
	pWaiter->SetOrder(bakeChickenWing1);
	pWaiter->SetOrder(bakeChickenWing2);
	pWaiter->SetOrder(bakeChickenWing3);
	pWaiter->SetOrder(bakeChickenWing4);
	pWaiter->SetOrder(bakeChickenWing5);
	pWaiter->SetOrder(bakeChickenWing6);

	// 客人向服务员取消烧烤(取消命令)
	pWaiter->CancelOrder(bakeMutton3);
	pWaiter->CancelOrder(bakeChickenWing6);

	// 服务员通知烧烤厨师按照菜单开始烤烧烤
	pWaiter->Notify();
}

好处

1、降低了系统耦合度。

2、新的命令可以很容易添加到系统中去