设计模式之对象行为型模式 — COMMAND （命令）模式

意图

将一个请求封装成一个对象 ，从而使你可以用不同的请求对客户进行参数化。对请求进行排队或者记录请求日志，以及支持可撤销的操作。

对象交互图

• Command 执行操作的接口
• client 创建具体的命令对象以及接受者
• Invoker 要求该命令执行的这个请求
• Receiver 接受者，任何类都可以作为接受者

代码示例

//test.h文件

#include <iostream>
#include <list>
using namespace std;

//接受者
class Receiver
{
public:
    Receiver();
    ~Receiver();

    void Action();
protected:
private:
};


//命令的抽象基类
class Command
{
public:
    virtual ~Command();
    virtual void Execute() = 0;
protected:
    Command();
private:
};

//Ex指令  
class ExCommand:public Command
{
public:
    ExCommand(Receiver *re);
    ~ExCommand();

    virtual void Execute();
protected:
private:
    Receiver *m_re;
};
//Ac指令
class AcCommand :public Command
{
public:
    AcCommand();
    ~AcCommand();
    virtual void Execute();

private:

};


//指令序列Bc  由Ex和Ac组合而成 
class BcCommmand:public Command
{
public:
    BcCommmand();
    virtual ~BcCommmand();

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

    virtual void Execute();

private:
    list <Command *> *m_com;
};

---

//test.cpp 文件

#include "test.h"

Command::~Command()
{

}


Command::Command()
{

}

/****************************/

Receiver::Receiver()
{

}

Receiver::~Receiver()
{

}

void Receiver::Action()
{
    cout << "正在执行操作" << endl;
}
/*************************************/
ExCommand::ExCommand(Receiver *re)
:Command(), m_re(re)
{

}

ExCommand::~ExCommand()
{

}

void ExCommand::Execute()
{
    cout <<"正在执行Ex指令 \n"<< "调用接受者\n....." << endl;
    m_re->Action();
}


AcCommand::AcCommand()
{

}

AcCommand::~AcCommand()
{
}

void AcCommand::Execute()
{
    cout << "正在执行Ac指令" << endl;
}

/*********************************/

BcCommmand::BcCommmand()
{
    m_com = new list<Command *>();
}

BcCommmand::~BcCommmand()
{
}

void BcCommmand::Add(Command *com)
{
    m_com->push_back(com);
}

void BcCommmand::Remove(Command *com)
{
    m_com->remove(com);
}

void BcCommmand::Execute()
{
    for (auto x:*m_com)
    {
        x->Execute();
    }
}

---

//main.cpp 文件  

#include "test.h"

int main()
{
    int a = 0;
    cout << "输入 1 执行Ex操作  \n输入 2 执行Ac 操作  \n输入 3 执行Bc 操作" << endl;
    Receiver *re = new Receiver();

    ExCommand *ex = new ExCommand(re);
    AcCommand *ac = new AcCommand();

    BcCommmand *bc = new BcCommmand();
    bc->Add(ex);
    bc->Add(ac);

    while (cin>>a)
    {
        switch (a)
        {
        case 1:   //Invoker  
            ex->Execute();
            break;
        case 2:
            ac->Execute();
            break;
        case 3:
            bc->Execute();
            break;
        default:
            break;
        }

    }
    system("pause");
    return 0;
}

效果

1. 将调用操作的对象与知道如何实现操作的对象解耦
2. 可以将多个命令装配成一个复合命令
3. 新增加命令也很容易，无需改变已有的类

---

我的个人网站 http://www.breeziness.cn/
我的CSDN http://blog.csdn.net/qq_33775402

转载请注明出处 小风code www.breeziness.cn