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

行为型模式

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

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

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

命令模式：行为型模式中的一种。

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

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

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

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

关键角色：

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

demo1

#include <iostream>
#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 <iostream>
using namespace std;

Receiver::Receiver(){

}
Receiver:: ~Receiver(){

}
void Receiver::action(){
    cout << "receiver action" <<endl;   
}

//抽象命令Command.h 
#ifndef _COMMAND_H_
#define _COMMAND_H_
class Command {
    public:

        //构造函数引入接收者
        Command(Receiver* pReceiver);
        //在具体命令实现中，可以通过具体命令不同发送给不同接收者，完成解耦
        virtual ~Command();
        virtual void execute();

    private:
        //引入接受者，
        Receiver* m_Receiver;
};
#endif

//Command.cpp
Command::Command(Receiver * pRecevier){
    //可实现，也可以子类重写
}
Command::~Command(){}
Command::execute(){}



//进入具体命令阶段 具体命令可以有多类，此处写一类。
//具体命令 ConcreateCommand.h

#ifndef _Concreate_Command_H_
#define _Concreate_Command_H_
class ConcreateCommand : public Command(){
        public:
            ConcreateCommand(Receiver* pReceiver);
            ~ConcreateCommand();
            void execute();
        private:
            Receiver * m_Receiver;
}
#endif
//子类具体命令实现
//具体命令ConcreateCommand.cpp
#include ConcreateCommand.h
#include <iostream>
using namespace std;

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

}
//完成具体命令的发送给接收者
void ConcreateCommand::execute(){
    cout<< "ConcreateCommand:: execute"<<endl;
    //完成接收者创建和执行
    m_pReceiver->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 <iostream>
using namespace std;

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

}
void Invoker::call(){
    cout << "invoker calling" <<endl;
    m_pCommand->execute();
}

优点缺点

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

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