（Boolan）C++设计模式 <十二> ——命令模式（Command）和访问器（Visitor）

“行为变化”模式

在组建的构建过程中，组建行为的变化经常导致组建本身剧烈的变化。“行为变化”模式将组建的行为和组建本身进行解耦，从而主持组件的变化，实现两者之间的松耦合。

• 典型模式
  • Command
  • Visitor

命令模式Command

将一个请求（行为）封装为对象，从而使你可用不同的请求，对客户进行参数化；对请求排队或记录请求日志以及支持可撤销的操作。
——《设计模式》GoF

• 动机
  在软件构建构成中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合——比如需要对行为进行“记录、撤销（undo）、事务”邓程澧，这种无法抵御变化的紧耦合是不合适的。

#include <iostream>#include <vector>#include <string>using namespace std;class Command{public:    virtual void execute() = 0;};class ConcreteCommand1 : public Command{    string arg;public:    ConcreteCommand1(const string & a) : arg(a) {}    void execute() override    {        cout<< "#1 process..."<<arg<<endl;    }};class ConcreteCommand2 : public Command{    string arg;public:    ConcreteCommand2(const string & a) : arg(a) {}    void execute() override    {        cout<< "#2 process..."<<arg<<endl;    }};class MacroCommand : public Command{    vector<Command*> commands;public:    void addCommand(Command *c) { commands.push_back(c); }    void execute() override    {        for (auto &c : commands)        {            c->execute();        }    }};int main(){    ConcreteCommand1 command1(receiver, "Arg ###");    ConcreteCommand2 command2(receiver, "Arg $$$");    MacroCommand macro;    macro.addCommand(&command1);    macro.addCommand(&command2);    macro.execute();}

Command有一个execute的虚函数，派生了一系列的子类，由单一的命令，也有宏命令（用到了Composite模式，继承自Command，动态遍历了容器中的Command命令，以实现了一组命令的组合）。在使用层面，我们拿到的是对象，但是表征的却是行为。可以通过一些容器的存放对象的模式，来实现出类似于剪切、撤销等操作，只需要将对象弹出或者压入即可。

Command的UML

要点总结

• Command模式的根本目的在于“行为请求者”与“行为实现者”解耦，在面向对象的语言中，常见的实现手段是“将行为抽象为对象”
• 实现Command接口的具体命令对象ConcreteCommand有时候根据需要可能会保存一些额外的状态信息。通过使用Composite模式，可以将多个“命令”封装为一个“符合命令”MacroCommand
  Command模式与C++中的函数对像有些类似。但两者定义行为接口的规范有所区别：Command以面向对象中的“接口-实现”来定义行为接口规范，更严格，但有性能损失；C++函数对象以函数签名来定义行为接口规范，更灵活，性能能高。

访问者Visitor

表示一个作用与某对像结构中的各元素的操作。使得可以在不改变（稳定）各元素的类的前提下定义（扩展）作用于这些元素的新操作（变化）。
——《设计模式》GoF

• 动机
  在软件构建的过程中，由于需求的改变，某些类层次结构中常常需要增加新的行为（方法）。如果直接在类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有设计。

#include <iostream>using namespace std;class Visitor;class Element{public:    virtual void accept(Visitor& visitor) = 0; //第一次多态辨析    virtual ~Element(){}};class ElementA : public Element{public:    void accept(Visitor &visitor) override {        visitor.visitElementA(*this);    }};class ElementB : public Element{public:    void accept(Visitor &visitor) override {        visitor.visitElementB(*this); //第二次多态辨析    }};class Visitor{public:    virtual void visitElementA(ElementA& element) = 0;    virtual void visitElementB(ElementB& element) = 0;    virtual ~Visitor(){}};//==================================//扩展1class Visitor1 : public Visitor{public:    void visitElementA(ElementA& element) override{        cout << "Visitor1 is processing ElementA" << endl;    }    void visitElementB(ElementB& element) override{        cout << "Visitor1 is processing ElementB" << endl;    }};//扩展2class Visitor2 : public Visitor{public:    void visitElementA(ElementA& element) override{        cout << "Visitor2 is processing ElementA" << endl;    }    void visitElementB(ElementB& element) override{        cout << "Visitor2 is processing ElementB" << endl;    }};int main(){    Visitor2 visitor;    ElementB elementB;    elementB.accept(visitor);// double dispatch    ElementA elementA;    elementA.accept(visitor);    return 0;}

当父类增加了新的操作，那么修改的代价极高，后续派生出来的所以子类都需要更改。违背了开闭原则。
应该是扩展新的需求该不是在修改的情况下添加新的操作。

#include <iostream>using namespace std;class Visitor;class Element{public:    virtual void Func1() = 0;    virtual void Func2(int data)=0;    virtual void Func3(int data)=0;    //...    virtual ~Element(){}};class ElementA : public Element{public:    void Func1() override{        //...    }    void Func2(int data) override{        //...    }};class ElementB : public Element{public:    void Func1() override{        //***    }    void Func2(int data) override {        //***    }};

Visitor 的UML

Visitor的缺点：对于Visitor来说，不仅仅需要Vistor和Element需要稳定，同时也需要ConcreteElementA和ConcreteElement这两个类也保持稳定，而这个条件是很难保证的。如果新增加了Element的子类，那么Visitor的基类就需要改变，同时也会牵扯到ConcreteVisitor。所以这就是Vistor的缺点。Visitor的条件很难达成。

要点总结

• Vistor模式通过所谓的双重分发（double dispatch）来实现现在不更改（不添加新的操作-编译时）Element类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作（支持变化）。
• 所谓双重分发即Vistor模式中包括了两个多态分发（注意其中的多态机制）：第一个accept方法的多态解析；第二个visitElementX方法的多态解析。
• Visitor模式最大的缺点在于扩展类层次结构（增添新的Element子类），会导致Visitor类的改变。因此Visitor模式适用于“Element类层次结构稳定，而其中的操作却进场面临频繁改动”。