• MenuItem ��������� ������는 ������ ��������� ������������는 action��� ������ ������를��� ������������������. ����������머는 procedural language��������� callback ���������럼 ��������������� ��� ������. Command는 callback��������� 대��� ������������������ 대���������.
  
  
• ���른 ������대��� request를 ����������������� queue�������� ������������ ���������. Command ������는 request��� 독립������ lifetime��� ������ ��� ������. 만��� request��� receiver��� ������ 독립������ 방������� (������������ 등) ������를 ��������� ��� ������면 ����������머는 request��� 대��� Command ������를 ���른 ����������������� ������������ ���리��� ��� ������.
  
  
• undo ���능��� ������������ ���������. Command��� Execute operation��� ������ Command��� ������를 ��돌리��� ������ state를 ��������� ��� ������. Command 는 Execute ��������� ������를 ��돌리��� ������ Unexecute operation��� �������������������� ������������ ������. �������� command는 history list��� �����������. history list를 ��� 뒤�� ���������면��� Unexecute��� Execute를 부���������� 무��������� undo���능��� redo���능��� ��������� ��� ������ �����.
  
  
• logging change를 ������������ ���������. logging change 를 ����������������� ��������� ���돌��� �� ��������� 대��� ������ command를 �������� ��� ��� ������. Command ��������� load ��� store operation��� ����������������� change��� log를 ��������� ��� ������. crash��부��� 복������는 ������ 디��������부��� logged command를 ������들������ Execute operation��� ������������는 ������ ��������� 부��������.
  
  
• ���본명������들를 ���������� ��������� ���������벨��� 명���들�� ������������ ��������� ���. ���러��� ��������� transaction��� ���������는 ���보��������������� 보�������� 방���������. transaction��� 데��������� 변������ ��������� ���������������. CommandPattern��� transaction��� 디���������는 �������� 방����� ������������. Command들��� �������� ���������������를 ������며, 모�� transaction를 ������ 방������� invoke��� ��� ������� ������. CommandPattern��� ������ �������� transaction들��� ������������ ��������������� ������ ������.
  
  

• Command
  
  - ��������� operation��� ������ ���������������를 ������������.
  
• ConcreteCommand (PasteCommand, OpenCommand)
  
  - Receiver ��������� action 묶������ ������������.
  
• Client (Application)
  
  - ConcreteCommand ������를 만들��� receiver�� ���������.
  
• Invoker (MenuItem)
  
  - command ������ request를 ������������� ������������.
  
• Receiver (Document, Application)
  
  - ���리��� request��� 대��� 명������들��� ���떻��� ������������ ������ ������ ������. �������� ������������� Receiver����� ���동���능������.
  
  

• client는 ConcreteCommand ������를 만들���, receiver를 ���������.
  
• Invoker ������는 ConcreteCommand������를 ������������.
  
• invoker는 command������ Execute를 ����������������� request를 issue������. 명��������� undo���능������, ConcreteCommand는 명������를 undo������ ������ state를 ������������.
  
• ConcreteCommand ������는 request를 ���리������ ������ receiver������ operation��� invoke������.
  
  

1. Command는 ������ ��������� 명������ invoke���는 ��������� ���떻��� ������������ ������ ������ ���는 ������������ ��������� ������������.
   
2. Command는 ���번������������ �������� ������������. Command는 �������������� ��� ������면��� ���른 ������들��� 마����������� ���������능������.
   
3. Command를 묶��� ��� ������. ������ ���명��� MacroCommand��� ��� ������ �����. ������������� composite command들��� CompositePattern��� ������������������.
   
4. �������� Command를 ��������������� ������. ���냐���면 ���미 ���������������는 ��������들��� ������ ��������� ������ ���문������.
   

~cpp 
class Command {
public:
	virtual ~Command ();

	virtual void Execute () = 0;
protected:
	Command ();
};

~cpp 
class PasteCommand : public Command {
public:
	PasteCommand (Document*);

	virtual void Execute ();
private:
	Document* _document;
};

PasteCommand::PasteCommand (Document* doc) {
	_document = doc;
}

void PasteCommand::Execute () {
	_document->Paste ();
}

~cpp 
template <class Receiver>
class SimpleCommand : public Command {
public:
	typedef void (Receiver::* Action) ();

	SimpleCommand (Receiver* r, Action a) : 
		_receiver (r), _action (a) { }

	vitual void Execute ();

private:
	Action _action;
	Receiver* _receiver;
};

~cpp 
template <class Receiver>
void Simplecommand<Receiver>::Execute () {
	(_receiver->*_action) ();

~cpp 
MyClass* receiver = new MyClass;
// ...
Command* aCommand = 
	new SimpleCommand<MyClass> (receiver, &MyClass::Action);
// ...
aCommand->Execute ();

~cpp 
class MacroCommand : public Command {
public:
	MacroCommand ();
	virtual ~MacroCommand ();

	virtual void Add (Command*);
	virtual void Remove (Command*);

	virtual void Execute ();

private:
	List<Command*>* _cmds;
};

~cpp 
void MacroCommand::Execute () {
	ListIterator<Command*> i (_cmds);
	
	for (i.First (); !i.IsDone (); i.Next()) {
		Command* c = i.CurrentItem ();
		c->Execute ();
	}
}

~cpp 
void MacroCommand::Add (Command* c) {
	_cmds->Append (c);
}

void MacroCommand::Remove (Command* c) {
	_cmds->Remove (c);
}