新版MQL语言程序设计：命令模式的原理、应用及代码实现

一、什么是命令模式

命令模式是一种行为设计模式，它将请求封装成一个对象，从而使你可以用不同的请求对客户端进行参数化。这种模式的主要目的是将方法的调用、请求或者操作封装到单一的对象中，然后通过调用该对象来实现对这些方法、请求或者操作的参数化和传递。

二、命令模式的实现原理

1. 定义命令接口：创建一个命令接口，其中包含执行命令的方法。

2. 实现具体命令类：创建具体的命令类，实现命令接口，并在其中实现具体的命令逻辑。

3. 创建命令调用者：创建一个命令调用者类，它包含一个命令对象作为成员变量，并提供一个方法来设置命令对象。

4. 调用者执行命令：调用者通过调用命令对象的执行方法来执行具体的命令。

5. 创建命令接收者：创建一个命令接收者类，它包含了实际执行命令的方法。

6. 将命令与接收者关联：将命令对象与接收者对象进行关联，使得命令对象可以调用接收者的方法来执行具体的操作。

三、命令模式的应用场景

• 撤销和重做操作：命令模式可以记录每个操作的命令对象，从而可以轻松地实现撤销和重做功能。
• 队列请求处理：命令模式可以将请求封装成命令对象，并将其放入队列中进行处理，从而实现异步、延迟或者顺序执行请求。
• 日志记录：命令模式可以记录每个操作的命令对象，从而可以方便地实现日志记录功能。
• 菜单或按钮操作：命令模式可以将菜单项或按钮操作封装成命令对象，从而实现灵活的菜单或按钮操作。

四、命令模式的代码实现

//+------------------------------------------------------------------+
//| interface — for patterns                                         |
//+------------------------------------------------------------------+
interface ClientInterface //pattern client
{
    string Output(void); //returns header
    void Run(void); //execute the pattern client
};
//+------------------------------------------------------------------+
//| interface — for patterns                                         |
//+------------------------------------------------------------------+
void Run(ClientInterface* client) //launches a pattern
{
    printf("---\n%s",client.Output()); //print pattern header
    client.Run(); //execute client collaborations
    delete client; //exit
}

//+------------------------------------------------------------------+
//| participants > receiver                                          |
//+------------------------------------------------------------------+
class Receiver
//   knows how to perform the request operations
//   any class may be a receiver
{
    public:
        Receiver(void);
        Receiver(Receiver&);
        void              Action(void);
};
//+------------------------------------------------------------------+
//| participants > receiver > default                                |
//+------------------------------------------------------------------+
Receiver::Receiver(void)
{

}
//+------------------------------------------------------------------+
//| participants > receiver > copy constructor                       |
//+------------------------------------------------------------------+
Receiver::Receiver(Receiver &src)
{

}
//+------------------------------------------------------------------+
//| participants > receiver > action                                 |
//+------------------------------------------------------------------+
void Receiver::Action(void)
{
    Print("receiver ",&this," action");
}
//+------------------------------------------------------------------+
//| participants > command                                           |
//+------------------------------------------------------------------+
class Command
{
    protected:
        Receiver*         m_receiver;
    public:
        Command(Receiver*);
        ~Command(void);
        virtual void      Execute(void)=0;
};
//+------------------------------------------------------------------+
//| participants > command > constructor                             |
//+------------------------------------------------------------------+
Command::Command(Receiver* receiver)
{
    m_receiver = new Receiver(receiver);
    Print("receiver ",receiver," accepted by command ",&this);
}
//+------------------------------------------------------------------+
//| participants > command > destructor                              |
//+------------------------------------------------------------------+
Command::~Command(void)
{
    if(CheckPointer(m_receiver)==1)
    {
        delete m_receiver;
    }
}
//+------------------------------------------------------------------+
//| participants > concrete command                                  |
//+------------------------------------------------------------------+
class ConcreteCommand:public Command
{
    protected:
        int               m_state;
    public:
        ConcreteCommand(Receiver*);
        void              Execute(void);
};
//+------------------------------------------------------------------+
//| participants > concrete command > constructor                    |
//+------------------------------------------------------------------+
ConcreteCommand::ConcreteCommand(Receiver* receiver): Command(receiver), m_state(0)
{
    Print("command ", &this, " state: ", m_state);
}
//+------------------------------------------------------------------+
//| participants > concrete command > execute                        |
//+------------------------------------------------------------------+
void ConcreteCommand::Execute(void)
{
    Print("command executes receiver ", m_receiver);
    m_receiver.Action();
    m_state = 1;
    Print("command ", &this, " state: ", m_state);
}
// 要求命令执行请求
class Invoker
{
    public:
        ~Invoker();
        void              StoreCommand(Command*);
        void              Execute(void);
    protected:
        Command          *m_command;
};
//+------------------------------------------------------------------+
//| participants > invoker > destructor                              |
//+------------------------------------------------------------------+
Invoker::~Invoker()
{
    if (CheckPointer(m_command) == 1)
    {
        delete m_command;
    }
}
//+------------------------------------------------------------------+
//| participants > invoker > command                                 |
//+------------------------------------------------------------------+
void Invoker::StoreCommand(Command* command)
{
    m_command = command;
    Print("command ", m_command, " stored");
}
//+------------------------------------------------------------------+
//| participants > invoker > execute                                 |
//+------------------------------------------------------------------+
void Invoker::Execute(void)
{
    Print("executing command ",m_command);
    m_command.Execute();
}
 // creates a concrete command object and sets its receiver
class Client:public ClientInterface
{
    public:
        string            Output(void);
        void              Run(void);
};
string Client::Output(void)
{
    return __FUNCTION__;
}
//+------------------------------------------------------------------+
//| collaborations                                                   |
//+------------------------------------------------------------------+
void Client::Run(void)
{
    Receiver receiver;
    Invoker invoker;
    invoker.StoreCommand(new ConcreteCommand(&receiver));
    invoker.Execute();
}
//
void OnStart()
{
    Run(new Client);
}