Command模式

Command模式

一．    意图

将一个请求封装为一个对象，从而使你可用不同的请求对客户记性参数化；对请求排队或记录请求日志，一级支持可撤销的操作。

 

二．    适用性

1.  抽象出待执行的动作以参数化某对象，你可用过程语言中的回调函数表达这种参数化机制。所谓回调函数是指函数现在某处注册，而它将在稍后某个需要的时候被调用。Command模式时回调机制的一个面向对象的替代品。

2.  在不同的时刻指定、排列和执行请求。一个command对象可以有一个与初始请求无关的生存期。如果一个请求的接受者可用一种与地址空间无关的方式表达，那么就可将负责该请求的命令对象传送给另一个不同的进程并在那儿实现该请求。

3.  支持取消操作。Command的excute操作可在实施操作前将状态存储起来，在取消操作时这个状态用来消除该操作的影响。Command接口必须添加一个unexecute操作，该操作取消上一次execute调用的效果。执行的命令被存储在一个历史表中。可通过向后和向前遍历这一列表并分别调用unexecute和execute来实现重数不限的取消和重做。

4.  支持修改日志，这样当系统崩溃时，这些修改可以被重做一遍。在command接口中添加装载操作和存储操作，可以用来保持变动的一个一致的修改日志，从崩溃中恢复的过程包括从磁盘中重新读入记录下来的命令并用execute操作重新执行塔门。

5.  用构建在原语操作上的高层操作构造一个系统，这样一种结构在支持事物的信息系统中很常见。一个事物封装了对数据的一组变动。Command模式提供了对事物进行建模的方法。Command有一个公共的接口，使得你可以用同一种方式调用所有的事务。同时使用该模式也易于添加新事物以扩展系统。

 

三．    结构

 

 

四．    代码

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

#include<vector>

#include<math.h>

 

usingnamespacestd;

//commandmode

//接收者

classCReceiver

{

public:

    voidCommandOne()

    {

        cout<<"Command******1******"<<endl;

    }

    voidCommandTwo()

    {

        cout<<"Command******2******"<<endl;

    }

    voidCommandThree()

    {

        cout<<"Command******3******"<<endl;

    }

};

//命令抽象类

classCCommand

{

public:

    CCommand(CReceiver*recevver)

    {

        m_pReceiver=recevver;

    }

    virtualvoidExecute(){}

protected:

    CReceiver*m_pReceiver=NULL;

};

//commandone

classCCommandOne:publicCCommand

{

public:

    CCommandOne(CReceiver*receiver):CCommand(receiver)

    {}

    voidExecute()

    {

        if(m_pReceiver==NULL)

        {

            return;

        }

 

        m_pReceiver->CommandOne();

    }

};

//commandtwo

classCCommandTwo:publicCCommand

{

public:

    CCommandTwo(CReceiver*receiver):CCommand(receiver)

    {}

    voidExecute()

    {

        if(m_pReceiver==NULL)

        {

            return;

        }

 

        m_pReceiver->CommandTwo();

    }

};

//commandthree

classCCommandThree:publicCCommand

{

public:

    CCommandThree(CReceiver*receiver):CCommand(receiver)

    {}

    voidExecute()

    {

        if(m_pReceiver==NULL)

        {

            return;

        }

 

        m_pReceiver->CommandThree();

    }

};

//命令执行者

classCInvoker

{

public:

    CInvoker()

    {

        m_command.clear();

    }

    virtual~CInvoker()

    {

        m_command.clear();

    }

 

    voidAddCommand(CCommand*command)

    {

        m_command.push_back(command);

    }

 

    voidCancelCommand(CCommand*command){}

 

    voidNotify()

    {

        intnCommandNum=m_command.size();

        if(nCommandNum<=0)

        {

            return;

        }

 

        for(inti=0;i<nCommandNum;i++)

        {

            m_command.at(i)->Execute();

        }

    }

private:

    vector<CCommand*>m_command;

};

 

intmain()

{

    cout<<"HelloWorld!"<<endl;

 

    //createclass

    CReceiver*receiver=newCReceiver();

    CInvoker*invoker=newCInvoker();

    //addcommand

    invoker->AddCommand(newCCommandOne(receiver));

    invoker->AddCommand(newCCommandTwo(receiver));

    invoker->AddCommand(newCCommandOne(receiver));

    invoker->AddCommand(newCCommandThree(receiver));

    invoker->AddCommand(newCCommandOne(receiver));

 

    //docommand

    invoker->Notify();

 

    //feeememery

    if(receiver!=NULL)

    {

        deletereceiver;

        receiver=NULL;

    }

    if(invoker!=NULL)

    {

        deleteinvoker;

        invoker=NULL;

    }

 

    return0;

}