C ++の設計パターン - コマンドモード

C ++の設計パターン - コマンドモード

参考URL：httpsを：//blog.csdn.net/u012611878/article/details/77726460

コマンドモード

ソフトウェアの設計では、我々は多くの場合、特定のオブジェクトに要求を送信する必要がありますが、要求の受信者が誰であるかを知らない、アクションが要求されているかわからない、我々は唯一のプログラムが実行され、受信者に特定の要求を指定する必要がありますこの時点で、コマンドモードは、より柔軟なオブジェクト間の関係を呼び出すように、互いの間の結合を排除するためにそのような要求の送信者と要求受信機を設計するために使用することができてもよいです。

完全にデカップル送信者と受信者は、送信者と受信者の間の関係には直接の言及はありません可能なコマンドモードは、オブジェクトは要求を完了する方法を知らなくても、リクエストを送信する方法を知っておく必要があり、要求を送信します。これは、コマンドモードモード動機です。

1.スキーマ定義

モードコマンド（Commandパターン）：カプセル化オブジェクトの要求、私たちはクライアントの要求に異なるパラメータを使用することができ、要求キューまたはログ要求、および取り消し可能操作をサポート。コマンドモードは、アクション（行動）モードまたはトランザクション（トランザクション）モードの別名であるオブジェクトの行動パターン、です。

2.モード構造

コマンドモードでは、次の役割が含まれています。

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

図コマンドモードクラス

達成するためのコマンドモード

#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;
}