C ++ patrones de diseño - modo de comando

C ++ patrones de diseño - modo de comando

Referencia URL: https: //blog.csdn.net/u012611878/article/details/77726460

Modo de comando

En el diseño de software, a menudo necesitamos para enviar una petición a ciertos objetos, pero no sabe quién es el destinatario de la solicitud, no saben lo que se está solicitando la acción, sólo tenemos que especificar una petición específica al destinatario que es cuando el programa se ejecuta puede, en este momento, el modo de comando se puede utilizar para diseñar un remitente dicha solicitud y el receptor solicitud para eliminar el acoplamiento entre sí, de modo que las relaciones entre los objetos más flexibles llamando.

El modo de comando puede remitentes y receptores DECOUPLE por completo, no hay ninguna referencia directa a la relación entre el emisor y el receptor, el objeto envía la solicitud sólo se necesita saber cómo enviar las solicitudes sin tener que saber cómo completar la solicitud. Este es el motivo modo de modo de comando.

1. definición de esquema

El modo de comando (Patrón de comandos): encapsular una solicitud de un objeto, de manera que podemos utilizar una parametrización diferente a las solicitudes del cliente; solicitudes de cola de solicitud o registro, y apoyar las operaciones se pueden deshacer. Modo de comando es un patrón de comportamiento objeto, que es un alias para el modo de acción (acción) de modo o transacción (transacciones).

2. Estructura Modo

El modo de comando contiene las siguientes funciones:

Command: 抽象命令类
ConcreteCommand: 具体命令类
Invoker: 调用者
Receiver: 接收者
Client:客户类

La figura mando de la clase Mode

El modo de comando para lograr

#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>
using namespace std;

/*-------------------------------------*/
class Receiver{
public:
    Receiver()= default;
    virtual ~Receiver() = default;

    virtual void Action() = 0;
};

class Command{
public:
    Command() = default;
    virtual ~Command() = default;
    virtual void Execute() = 0;
};

/*-------------------------------------*/
class ReceiverA : public Receiver{
public:
    ReceiverA() = default;
    ~ReceiverA() override = default;
    void Action() override {
        cout << "receiverA action." << endl;
    }
};

class ReceiverB : public Receiver{
public:
    ReceiverB() = default;
    ~ReceiverB() override = default;
    void Action() override {
        cout << "receiverB action." << endl;
    }
};

class ConcreteCommandA : public Command{
public:
    ConcreteCommandA(std::unique_ptr<Receiver>&& receiver):mReceiver(std::move(receiver)){};
    ~ConcreteCommandA() override{std::cout<<"~ConcreteCommandA()"<<std::endl;};
    void Execute() override {
        cout << "ConcreteCommandA::execute" << endl;
        mReceiver->Action();
    }
private:
    std::unique_ptr<Receiver> mReceiver = nullptr;
};

class ConcreteCommandB : public Command{
public:
    ConcreteCommandB(std::unique_ptr<Receiver>&& receiver):mReceiver(std::move(receiver)){};
    ~ConcreteCommandB() override {std::cout<<"~ConcreteCommandB()"<<std::endl;};;
    void Execute() override {
        cout << "ConcreteCommandB::execute" << endl;
        mReceiver->Action();
    }
private:
    std::unique_ptr<Receiver> mReceiver = nullptr;
};

/*-------------------------------------*/
class Invoker{
public:
    Invoker() = default;
    ~Invoker()= default;
public:
    void AddCommand(std::unique_ptr<Command>&& command){
        mCommandList.emplace_back(std::move(command));
    }
    void ClearCommand(){
        mCommandList.clear();
    }
    void Call() {
        cout << "invoker calling" << endl;
        for_each(mCommandList.begin(),mCommandList.end(),[](std::unique_ptr<Command>& command){command->Execute();});
    }
private:
    std::vector<unique_ptr<Command>> mCommandList;
};

int main(){
    {
        std::unique_ptr<Receiver> receiverA(new ReceiverA());
        std::unique_ptr<Receiver> receiverB(new ReceiverB());
        std::unique_ptr<Invoker> invoker (new Invoker());

        std::unique_ptr<Command> commandA (new ConcreteCommandA(std::move(receiverA)));
        std::unique_ptr<Command> commandB (new ConcreteCommandB(std::move(receiverB)));

        invoker->AddCommand(std::move(commandA));
        invoker->AddCommand(std::move(commandB));
        invoker->Call();

        invoker->ClearCommand();
    }
    return 0;
}