设计模式之命令模式

优点：实现调用操作的对象和调用操作的具体实现之间的解耦。（很拗口）

实现命令的操作操作的类

#pragma once
class Receive
{
public:
    Receive();
    ~Receive();

    void Action();
};

#include "Receive.h"
#include <iostream>


Receive::Receive()
{
}


Receive::~Receive()
{
}

void Receive::Action()
{
    std::cout << "Receive Action..." << std::endl;
}

 

命令

#pragma once
class Command
{
public:
    virtual ~Command();

    virtual void Excute() = 0;

protected:
    Command();
};

#include "Command.h"


Command::Command()
{
}


Command::~Command()
{
}

void Command::Excute()
{

}

 

命令派生类

#pragma once
#include "Command.h"

class Receive;

class ConcreateCommand :
    public Command
{
public:
    ConcreateCommand(Receive *rev);
    ~ConcreateCommand();

    void Excute();

private:
    Receive *m_rev;
};

#include "ConcreateCommand.h"
#include "Receive.h"
#include <iostream>


ConcreateCommand::ConcreateCommand(Receive *rev)
{
    this->m_rev = rev;
}


ConcreateCommand::~ConcreateCommand()
{
}

void ConcreateCommand::Excute()
{
    m_rev->Action(); //执行命令类的操作
    std::cout << "ConcreateCommand..." << std::endl;
    return;
}

 

调用者

#pragma once

class Command;


class Invoker
{
public:
    Invoker(Command *cmd);
    ~Invoker();

    void Invoke();

protected:
    Command *m_cmd;
};

#include "Invoker.h"
#include "Command.h"


Invoker::Invoker(Command *cmd)
{
    m_cmd = cmd;
}


Invoker::~Invoker()
{
}

void Invoker::Invoke()
{
    m_cmd->Excute();//执行命令
    return;
}

 

测试

#include <iostream>
#include "ConcreateCommand.h"
#include "Invoker.h"
#include "Receive.h"

int main()
{
    Receive *rev = new Receive();//操作对象的具体操作类实例化

    Command *cmd = new ConcreateCommand(rev);//操作类实例化，及操作对象

    Invoker *invoker = new Invoker(cmd);//调用操作对象具体操作的对象

    invoker->Invoke();

    if (rev)
    {
        delete rev;
        rev = NULL;
    }

    if (cmd)
    {
        delete cmd;
        cmd = NULL;
    }

    if (invoker)
    {
        delete invoker;
        invoker = NULL;
    }
    std::cout << "Hello World!\n"; 
}