行为型模式之命令模式实现

概念

命令模式是行为设计模式的一种。命令模式通过被称为Command的类封装了对目标对象的调用行为以及调用参数。

在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例；设置调用参数；调用目标对象的方法。

但在有些情况下必须要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。整个调用过程比较繁杂，或者存在多处这种调用。这时，使用Command类对该调用加以封装，便于功能的再利用。

调用前后需要对调用参数进行某些处理。调用前后需要进行某些额外处理，比如日志，缓存，记录历史操作等。

角色和职责

Command：Command命令的抽象类；
ConcreteCommand： Command的具体实现类；
Receiver： 需要被调用的目标对象；
Invorker： 通过Invorker执行Command对象。

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

案例

#include <iostream>
using namespace std;

class Vendor 
{
public:
    void sailBanana()
    {
        cout << "卖香蕉" << endl;
    }

    void sailApple()
    {
        cout << "卖苹果" << endl;
    }
};

class Command
{
public:
    virtual void sail() = 0;
};

class BananaCommand:public Command
{
public:
    BananaCommand(Vendor *v)
    {
        m_v = v;
    }

    Vendor *getV()
    {
        return m_v;
    }

    void setV(Vendor *v)
    {
        m_v = v;
    }

    virtual void sail()
    {
        m_v->sailBanana();
    }
private:
    Vendor *m_v;
};

class AppleCommand:public Command
{
public:
    AppleCommand(Vendor *v)
    {
        m_v = v;
    }

    Vendor *getV()
    {
        return Vendor;
    }

    void setV(Vendor *v)
    {
        m_v = v;
    }

    virtual void sail()
    {
        m_v->sailApple();
    }
private:
    Vendor *m_v;
};

class Waiter
{
public:
    Command *getCommand()
    {
        return m_command;
    }

    void setCommand(Command *c)
    {
        m_command = c;
    }

    void sail()
    {
        m_command->sail();
    }

private:
    Command *m_command;
};

class AdvWaiter
{
public:
    AdvWaiter()
    {
        m_list = new list<Command *>;
        m_list->resize(0);
    }

    ~AdvWaiter()
    {
        delete m_list;
    }

    list<Command *> *getCommand()
    {
        return list;
    }

    void setCommand(Command *c)
    {
        m_list->push_back(c);
    }

    void sail()
    {
        for(list<Command *>::iterator it = m_list->begin(); it != m_list->end(); it++)
        {
            (*it)->sail();
        }
    }

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

//小商贩 **直接** 卖 水果
void main1()
{
    Vendor *v = new Vendor();
    v->sailApple();
    v->sailBanana();

    delete v;
    return;
}

//小商贩 **通过命令** 卖 水果
void main2()
{
    Vendor *v = new Vendor();
    AppleCommand *ac = new AppleCommand(v);
    ac->sail();

    BananaCommand *bc = new BananaCommand (v);
    ac->sail();

    delete bc;
    delete ac;
    delete v;
}

//小商贩 **通过wait** 卖 水果
void main3()
{
    Vendor *v = new Vendor();
    AppleCommand *ac = new AppleCommand(v);
    BananaCommand *bc = new BananaCommand(v);

    Waiter *w = new Waiter();
    w->setCommand(ac);
    w->sail();

    w->setCommand(bc);
    w->sail();

    delete w;
    delete bc;
    delete ac;
    delete v;
}

//小商贩 **通过AdvWait** 卖 水果
void main4()
{
    Vendor *v = new Vendor();
    AppleCommand *ac = new AppleCommand(v);
    BananaCommand *bc = new BananaCommand(v);

    AdvWaiter *w = new AdvWaiter();
    w->setCommand(ac);
    w->setCommand(bc);
    w->sail();

    delete w;
    delete bc;
    delete ac;
    delete v;
}

int main(void)
{
    //main1();
    //main2();
    //main4();
    main4();
    return 0;
}