c++设计模式之命令模式

命令模式:
场景：
对一个对象要进行很多动作，每个动作就是一个命令。在原有的逻辑中，需要在客户端写出许多分支语句，针对内个动作，调用该对象类的成员函数。每增加一个动作，都需要在客户端和对象类中修改代码。违背了高内聚，低耦合的原则。因此，对于这种情况就可以使用命令模式。
组成元素:
1.抽象命令类
2.具体命令类(动作)
3.接受者(接受动作的对象)
4.装配者，增加删除命令，从而形成命令链
结构： 1.抽象命令类:很多动作，那么都需要有很多命令类，为了代码层次性更好，最好抽象出一个抽象的命令类。该类应该有一个执行函数，子类继承该函数(excute函数)，在该成员函数中，调用接受者的成员函数,因此在抽象命令类中应该有一个接受者成员变量
2.具体命令类:继承具体抽象类，执行具体的动作
3.接受者：针对具体的命令编写具体的执行成员函数
4.装配者:增加或者删除命令对象，形成命令链

//Paint.h
#pragma once
#include <iostream>
using namespace std;
class Picture
{
public:
    Picture();
    ~Picture();
    void Rotate();
    void Translation();
    void Stretch();
};

//Paint.cpp
#include "pch.h"
#include "Paint.h"


Picture::Picture()
{
}


Picture::~Picture()
{
}

void Picture::Rotate() 
{
    cout << "rotate" << endl;
}

void Picture::Translation() 
{
    cout << "translation" << endl;
}

void Picture::Stretch() 
{
    cout << "stretch" << endl;
}

//ICommand.h
#pragma once
#include <iostream>
#include "Paint.h"
using namespace std;

class ICommand
{
public:
    ICommand(Picture* picture);
    ~ICommand();
protected:
    Picture* picture_;
public:
    virtual void excute() = 0;
};


class CmdRotate:public ICommand
{
public:
    CmdRotate(Picture* picture);
    void excute();
};

class CmdTranslation:public ICommand
{
public:
    CmdTranslation(Picture* picture);
    void excute();
};

class CmdStretch:public ICommand
{
public:
    CmdStretch(Picture* picture);
    void excute();
};

//ICommand.cpp
#include "pch.h"
#include "ICommand.h"


ICommand::ICommand(Picture* picture)
{
}


ICommand::~ICommand()
{
}

CmdRotate::CmdRotate(Picture* picture) :ICommand(picture) {}

void CmdRotate::excute() 
{
    picture_->Rotate();
}

CmdTranslation::CmdTranslation(Picture* picture) :ICommand(picture) {}

void CmdTranslation::excute() 
{
    picture_->Translation();
}


CmdStretch::CmdStretch(Picture* picture) :ICommand(picture) {}

void CmdStretch::excute() 
{
    picture_->Stretch();
}

//Invoker.h
#pragma once
#include <list>
#include "ICommand.h"
class Invoker
{
public:
    Invoker();
    ~Invoker();
    void AddCmd(ICommand* cmd);
    void RemoveCmd(ICommand* cmd);
    void notify();
private:
    std::list<ICommand*> cmd_list;
};

//Invoker.cpp
#include "pch.h"
#include "Invoker.h"


Invoker::Invoker()
{
}


Invoker::~Invoker()
{
}

void Invoker::AddCmd(ICommand* cmd) 
{
    cmd_list.push_back(cmd);
}

void Invoker::RemoveCmd(ICommand* cmd) 
{
    cmd_list.remove(cmd);
}

void Invoker::notify() 
{
    std::list<ICommand*>::iterator it = cmd_list.begin();
    for (;it!=cmd_list.end();it++)
    {
        (*it)->excute();
    }
}

//main.cpp
#include "pch.h"
#include <iostream>
#include "ICommand.h"
#include "Paint.h"
#include "Invoker.h"
using namespace std;


#define SAFE_DELETE(p){ if(p){delete(p);(p)=NULL; } }

int main()
{
    Picture* picture = new Picture;
    ICommand* rotate_cmd = new CmdRotate(picture);
    ICommand* translation_cmd = new CmdTranslation(picture);
    ICommand* stretch_cmd = new CmdStretch(picture);

    Invoker* invo = new Invoker;
    invo->AddCmd(rotate_cmd);
    invo->AddCmd(translation_cmd);
    invo->AddCmd(stretch_cmd);

    invo->notify();

    SAFE_DELETE(picture);
    SAFE_DELETE(rotate_cmd);
    SAFE_DELETE(translation_cmd);
    SAFE_DELETE(stretch_cmd);
    SAFE_DELETE(invo);

    getchar();
}

运行结果: