Command模式

                    命令（Command）模式属于对象的行为模式【GOF95】。命令模式又称为行动（Action）模式或交易（Transaction）模式。命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

　　适用性：在软件系统中，行为请求者与行为实现者之间通常呈现一种紧耦合的关系。但在某些场合，比如要对行为进行记录撤销重做事务等处理，这种无法抵御变化的紧耦合是不合适的。这种情况下，使用command模式将行为请求者与行为实现者进行解耦。

 

                    这是我举例子的类图(比较挫...)

                   

 

                       代码实现：

#ifndef OPERATOR_H

#define OPERATOR_H

enum Operator {FORWARD, BACK};

#endif // OPERATOR_H

 

#ifndef COMMAND_H

#define COMMAND_H

#include "Operator.h"

#include <iostream>

class Command

{

public:

    Command(Operator _operator);

    virtual ~Command() {std::cout <<"c~\n";}

    virtual void operation() = 0;

    Operator getOperator() const {return _comOperator;}

private:

    Operator _comOperator;

};

#endif // COMMAND_H

#include "command.h"

Command::Command(Operator _operator):_comOperator(_operator)

{

}

#ifndef FORWARDCOMMAND_H

#define FORWARDCOMMAND_H

#include "command.h"

#include "receiver.h"

class ForwardCommand : public Command

{

public:

    ForwardCommand(Operator _operator, Receiver *_rev);

    ~ForwardCommand(){delete rev;}

    void operation();

private:

    Receiver *rev;

};

#endif // FORWARDCOMMAND_H

#include "forwardcommand.h"
ForwardCommand::ForwardCommand(Operator _operator, Receiver *_rev):Command(_operator),rev(_rev)
{
}
void ForwardCommand::operation()
{
    rev->execute();
}
#ifndef BACKCOMMAND_H
#define BACKCOMMAND_H
#include "command.h"
#include "receiver.h"
class BackCommand : public Command
{
public:
    BackCommand(Operator _com, Receiver* _rev);
    ~BackCommand(){delete rev;}
    void operation();
private:
    Receiver *rev;
};
#endif // BACKCOMMAND_H
#include "backcommand.h"
BackCommand::BackCommand(Operator _com, Receiver *_rev):Command(_com),rev(_rev)
{
}
void BackCommand::operation()
{
    rev->execute();
}
#ifndef RECEIVER_H
#define RECEIVER_H
#include <iostream>
class Receiver
{
public:
    Receiver();
    virtual ~Receiver(){std::cout <<"r~\n";}
    virtual void execute() = 0;
};
#endif // RECEIVER_H
#include "receiver.h"
Receiver::Receiver()
{
}
 
#ifndef FORWARDRECEIVER_H
#define FORWARDRECEIVER_H
#include "receiver.h"
class ForwardReceiver : public Receiver
{
public:
    ForwardReceiver();
    ~ForwardReceiver(){}
    void execute();
};
#endif // FORWARDRECEIVER_H
#include "forwardreceiver.h"
ForwardReceiver::ForwardReceiver()
{
}
void ForwardReceiver::execute()
{
     std::cout <<"ForwardCommand\n";
}
#ifndef BACKRECEIVER_H
#define BACKRECEIVER_H
#include "receiver.h"
class BackReceiver : public Receiver
{
public:
    BackReceiver();
    ~BackReceiver(){}
    void execute();
};
#endif // BACKRECEIVER_H
#include "backreceiver.h"
BackReceiver::BackReceiver()
{
}
void BackReceiver::execute()
{
    std::cout <<"backCommand\n";
}
#ifndef INVOKER_H
#define INVOKER_H
#include "Operator.h"
#include <vector>
#include "command.h"
class Invoker
{
public:
    Invoker();
    ~Invoker();
    void invoke(Operator _com);
    void addCommand(Command *_com);
private:
    std::vector<Command*> CommandList;
};
#endif // INVOKER_H
#include "invoker.h"
Invoker::Invoker()
{
}
Invoker::~Invoker()
{
    std::vector<Command*>::iterator ite;
    for (ite = CommandList.begin();ite != CommandList.end();++ite) {
        delete (*ite);
    }
    CommandList.clear();
}
void Invoker::addCommand(Command *_com)
{
    //这里可以做一些判断防止相同的对象生成
    CommandList.push_back(_com);
}
void Invoker::invoke(Operator _com)
{
    std::vector<Command*>::iterator ite;
    for (ite = CommandList.begin();ite != CommandList.end();++ite) {
        if ((*ite)->getOperator()== _com) {
            (*ite)->operation();
        }
    }
}
#include <iostream>
using namespace std;
#include "invoker.h"
#include "backcommand.h"
#include "backreceiver.h"
#include "forwardcommand.h"
#include "forwardreceiver.h"
int main()
{
    Invoker in;
    in.addCommand(new ForwardCommand(FORWARD,new ForwardReceiver));//不建议这样写，容易造成内存泄漏
    in.addCommand(new BackCommand(BACK,new BackReceiver));
    in.invoke(FORWARD);
    return 0;
}