命令模式

命令模式 将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

#include <iostream>
#include <string>


using namespace std;


struct Command {
    virtual void execute() = 0;
    virtual void undo() = 0;
};

struct NoCommand : public Command {
    void execute() {};
    void undo() {};
};

struct RemoteControl {
    Command *onCommands[7];
    Command *offCommands[7];
    Command *undoCommand;

    RemoteControl() {
        //onCommands = new NoCommand[7];
        //offCommands = new NoCommand[7];
        Command *noCommand = new NoCommand();

        for (int i = 0; i < 7; ++i)
        {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;
    }

    void setCommand(int slot, Command *onCommand, Command *offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    void onButtonWasPushed(int slot) {
        onCommands[slot]->execute();
        undoCommand = onCommands[slot];
    }

    void offButtonWasPushed(int slot) {
        offCommands[slot]->execute();
        undoCommand = offCommands[slot];
    }

    void undoButtonWasPushed() {
        undoCommand->undo();
    }

    string toString() {
        //string stringBuffer = new string;
    }
};

struct Light {
public:
    Light(string mname) {
        name = mname;
    }
    on() {
        cout << name << "Light on" << endl;
    }
    off() {
        cout << name << "Light off" << endl;
    }
private:
    string name;
};

struct LightOnCommand : public Command {
    Light *light;

    LightOnCommand(Light *mlight) {
        light = mlight;
    }

    virtual void execute() {
        light->on();
    }

    virtual void undo() {
        light->off();
    }
};

struct LightOffCommand : public Command {
    Light *light;

    LightOffCommand(Light *mlight) {
        light = mlight;
    }

    virtual void execute() {
        light->off();
    }

    virtual void undo() {
        light->on();
    }
};

struct CeilingFan {
public:
    CeilingFan(string mname) {
        name = mname;
    }
    on() {
        cout << name << "CeilingFan on" << endl;
    }
    off() {
        cout << name << "CeilingFan off" << endl;
    }
private:
    string name;
};

struct CeilingFanOnCommand : public Command {
    CeilingFan *ceilingFan;

    CeilingFanOnCommand(CeilingFan *mceilingFan) {
        ceilingFan = mceilingFan;
    }

    virtual void execute() {
        ceilingFan->on();
    }

    virtual void undo() {
        ceilingFan->off();
    }
};

struct CeilingFanOffCommand : public Command {
    CeilingFan *ceilingFan;

    CeilingFanOffCommand(CeilingFan *mceilingFan) {
        ceilingFan = mceilingFan;
    }

    virtual void execute() {
        ceilingFan->off();
    }

    virtual void undo() {
        ceilingFan->on();
    }
};

struct MacroCommand : public Command {
public:
    MacroCommand(Command **mCommand, int cnt) {
        commands = mCommand;
        commands_cnt = cnt;
    }

    virtual void execute() {
        for (int i = 0; i < commands_cnt; ++i) {
            commands[i]->execute();
        }
    }

    virtual void undo() {
        for (int i = 0; i < commands_cnt; ++i) {
            commands[i]->undo();
        }
    }
private:
    Command **commands;
    int commands_cnt;
};

// Remote loader
int main(int argc, char **argv)
{
    RemoteControl *remoteControl = new RemoteControl();

    Light *livingRoomLight = new Light("Living Room");
    Light *kitchenLight = new Light("Kitchen");
    CeilingFan *ceilingFan = new CeilingFan("Living Room");

    LightOnCommand *livingRoomLightOn =
        new LightOnCommand(livingRoomLight);
    LightOffCommand *livingRoomLightOff =
        new LightOffCommand(livingRoomLight);

    LightOnCommand *kitchenLightOn =
        new LightOnCommand(kitchenLight);
    LightOffCommand *kitchenLightOff =
        new LightOffCommand(kitchenLight);

    CeilingFanOnCommand *ceilingFanOn =
        new CeilingFanOnCommand(ceilingFan);
    CeilingFanOffCommand *ceilingFanOff =
        new CeilingFanOffCommand(ceilingFan);

    remoteControl->setCommand(0, livingRoomLightOn, livingRoomLightOff);
    remoteControl->setCommand(1, kitchenLightOn, kitchenLightOff);
    remoteControl->setCommand(2, ceilingFanOn, ceilingFanOff);

    //print log
    remoteControl->onButtonWasPushed(0);
    remoteControl->offButtonWasPushed(0);
    remoteControl->undoButtonWasPushed();
    remoteControl->onButtonWasPushed(1);
    remoteControl->offButtonWasPushed(1);
    remoteControl->onButtonWasPushed(2);
    remoteControl->offButtonWasPushed(2);
    remoteControl->undoButtonWasPushed();

    Command *partyOn[] = {livingRoomLightOn, kitchenLightOn, ceilingFanOn};
    Command *partyOff[] = {livingRoomLightOff, kitchenLightOff, ceilingFanOff};
    MacroCommand *partyOnCommand = new MacroCommand(partyOn, 3);
    MacroCommand *partyOffCommand = new MacroCommand(partyOff, 3);
    remoteControl->setCommand(3, partyOnCommand, partyOffCommand);
    remoteControl->onButtonWasPushed(3);
    remoteControl->offButtonWasPushed(3);
    remoteControl->undoButtonWasPushed();

    return 0;
}