新版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);
}

你可能感兴趣的:(新版MQL语言程序设计,命令模式,设计模式,学习,笔记,MQL,MT4,MT5)