行为型设计模式---命令模式

1、不仅仅关注类和对象结构、而且关注他们之间的相互作用。

2、注重对象之间的协同。

对象行为模式：使用对象的聚合关联关系来分配行为。对合成复用原则、尽量使用关联关系来替代继承关系。

定义：将一个请求封装为对象，从而使我们用不同请求对客户发出不同行为。

发送者和接受者之间解耦。

从图1 可以看出是一种调用者到命令、命令抽象化，根据具体命令执行具体动作，然后到客户端的接受者。

从图2 可以看出 通过命令的参数化，完成不同行为的动作。

发令者->抽象命令->具体命令 <--接受对象<-客户端。

#include 
#include "ConcreteCommand.h"
#include "Invoker.h"
#include "Receiver.h"

using namespace std;

int main (int argc, char *argv[])
{
    //接受者
    Receiver* pReceiver = new Receiver();

    //具体命令到达接受者
    ConcreateCommand* pCommand = new ConcreateCommand(pReceiver);

    //调用者调用命令，这里可以做分化，不同的具体命令发给不同的接收者。
    Invoker * pInvoker = new Invoker(pCommand);

    //行为发起 调用具体命令。
    pInvoker->call();

    delete pReceiver();
    delete pCommand();
    delete PInvoker();
    return 0;
}

//Receiver.h
#ifndef __RECEIVER___H_
#define __RECEIVER___H_
class Receiver{
    public:
            Receiver();
            virtual ~Receiver();
            void action();
    private:

};

#endif

//Receiver.cpp
#include "Receiver.h"
#include 
using namespace std;

Receiver::Receiver(){

}
Receiver:: ~Receiver(){

}
void Receiver::action(){
    cout << "receiver action" <
using namespace std;

ConcreateCommand::ConcreateCommand(Receiver* pReceiver){
    m_Receiver = pReceiver;
}
ConcreateCommand:: ~ConcreateCommand(){

}
//完成具体命令的发送给接收者
void ConcreateCommand::execute(){
    cout<< "ConcreateCommand:: execute"<action();
}

//调用者 命令发起者 调用命令对象 这这里可以调用不同的具体命令，完成解耦。
//Invoker.h

#ifndef _INVOKER_H_
#define _INVOKER_H_
#include "Command.h"
class Invoker{
    public:
        Invoker(Command * pCommand);
        virtual  ~Invoker();
        void call();
    private:
        Command* m_pCommand;
}
#endif

//Invoker.cpp
#include Invoker.h
#include 
using namespace std;

Invoker::Invoker(Command* pCommand){
    m_pCommand = pCommand;
}
Invoker::~Invoker(){

}
void Invoker::call(){
    cout << "invoker calling" <execute();
}

优点：降低耦合、新的命令易加入。

缺点：每一个动作都需要一个具体命令、可能导致系统复杂、存在大量具体命令。