22 行为型模式-----访问者模式

模式动机(Visitor Pattern)：访问者模式用于操作存储于某个集合中的各元素，使得可以在不改变元素类的前提下定义作用于这些元素的新操作。

之所以使用访问者类，是因为存储于某个集合中的元素可能具有不同的特性，而不同的访问者可能更看重某一方面的特性，如果让集合类本身承担访问操作，那么对于不同的访问操作，必须对应地定义不同的方法，不仅使得类变得极其庞大，而且难以扩展。

利用访问者模式可以解决上述问题。其将集合中元素的操作封装在一个Visitor继承体系中，不同的Visitor实现类可以满足不同的访问需求，增加新的访问方式只需添加一个ConcreteVisitor，系统中负责存储数据的集合类不需要做丝毫的变动。因此访问者模式的核心就是：在不改变存储元素类的前提下定义作用于这些元素的新操作。

 

参与者：

Visitor: 定义了访问不同特性元素的接口。

ConcreteVisitor: 实现了对于特定元素的访问操作。

Element: 定义了一个接受访问者的Accept操作接口。

ConcreteElement: 实现了Accept操作，根据不同的元素类型及其访问者类型实现访问操作。

ObjectStructure: 存储不同类型的元素，对外提供增加和删除元素的接口，以及接受一个访问者对象来访问存储的元素。

 

合作：

一个使用Visitor模式的客户必须创建一个ConcreteVisitor对象，然后遍历存储元素的结构对象ObjectStructure，并用指定的访问者访问这些元素；当一个具体的元素被访问时，它会调用与自身类型相关的Visitor操作。

 

模式结构图：

 

模式代码：

bt_访问者模式.h：

#ifndef VP_H
#define VP_H
#include <iostream>
#include <list>
using namespace std;

/*
    抽象元素
*/
class Visitor;
class Element
{
public:
    virtual ~Element() = 0;
    virtual void Accept(Visitor* v) = 0;
};

/*
    具体元素
*/
class ConcreteElementA : public Element
{
public:
    void Accept(Visitor* v);
    void OperationA();
};
class ConcreteElementB : public Element
{
public:
    void Accept(Visitor* v);
    void OperationB();
};

/*
    抽象访问者
*/
class Visitor
{
public:
    virtual ~Visitor() = 0;
    virtual void VisitConcreteElementA(ConcreteElementA* pEA) = 0;
42     virtual void VisitConcreteElementB(ConcreteElementB* pEB) = 0;
};

/*
    具体访问者
*/
class ConcreteVisitor1 : public Visitor
{
public:
    virtual void VisitConcreteElementA(ConcreteElementA* pEA);
52     virtual void VisitConcreteElementB(ConcreteElementB* pEB);
};
class ConcreteVisitor2 : public Visitor
{
public:
    virtual void VisitConcreteElementA(ConcreteElementA* pEA);
58     virtual void VisitConcreteElementB(ConcreteElementB* pEB);
};

/*
    对象结构
*/
class ObjectStructure
{
public:
    ObjectStructure();
    ~ObjectStructure();
    void AddElement(Element* elem);
    void RemoveElement(Element* elem);
    void Accept(Visitor* v);

private:
    list<Element*>* elements;
};
#endif // VP_H

bt_访问者模式.cpp:

#include "bt_访问者模式.h"

/* 抽象元素 */
Element::~Element(){  }

/* 具体元素 */
 7 void ConcreteElementA::Accept(Visitor* v){ v->VisitConcreteElementA(this); }
void ConcreteElementA::OperationA(){ cout << "Operation A" << endl; }
void ConcreteElementB::Accept(Visitor* v){ v->VisitConcreteElementB(this); }
void ConcreteElementB::OperationB(){ cout << "Operation B" << endl; }


/* 抽象访问者 */
Visitor::~Visitor(){  }

/* 具体访问者 */
17 void ConcreteVisitor1::VisitConcreteElementA(ConcreteElementA* pEA)
{
    cout << "Visitor1 visits ConcreteElementA" << endl;
    pEA->OperationA();
}
void ConcreteVisitor1::VisitConcreteElementB(ConcreteElementB* pEB)
{
    cout << "Visitor1 visits ConcreteElementB" << endl;
    pEB->OperationB();
}
void ConcreteVisitor2::VisitConcreteElementA(ConcreteElementA* pEA)
{
    cout << "Visitor2 visits ConcreteElementA" << endl;
    pEA->OperationA();
}
void ConcreteVisitor2::VisitConcreteElementB(ConcreteElementB* pEB)
{
    cout << "Visitor2 visits ConcreteElementB" << endl;
    pEB->OperationB();
}

/* 对象结构 */
ObjectStructure::ObjectStructure(){ elements = new list<Element*>; }
ObjectStructure::~ObjectStructure(){ delete elements; }

void ObjectStructure::AddElement(Element* elem){ elements->push_back(elem); }
void ObjectStructure::RemoveElement(Element* elem){ elements->remove(elem); }

45 void ObjectStructure::Accept(Visitor* v)
46 {
47     list<Element*>::iterator iter;
48     for(iter = elements->begin(); iter != elements->end(); iter++)
49     {
50         (*iter)->Accept(v);
51     }
52 }

测试用例.cpp:

#include "bt_访问者模式.h"

int main()
{
    cout << "***** 访问者模式测试 *****" << endl;
    ObjectStructure* obj = new ObjectStructure;
    Element* elementA1 = new ConcreteElementA;
    Element* elementA2 = new ConcreteElementA;
    Element* elementB1 = new ConcreteElementB;
    Element* elementB2 = new ConcreteElementB;

    obj->AddElement(elementA1);
    obj->AddElement(elementA2);
    obj->AddElement(elementB1);
    obj->AddElement(elementB2);

    Visitor* visitor1 = new ConcreteVisitor1;
    Visitor* visitor2 = new ConcreteVisitor2;

    obj->Accept(visitor1);
    cout << endl;
    obj->Accept(visitor2);

    return 0;
}

 

模式分析：

：： 访问者模式使得在不改变元素类的情况下可以增加新的操作，其使用了一种”Double Dispatch”模式，即具体访问操作依赖于具体的Element类型和Visitor类型两个方面，如上程序中：obj->Accept(visitor1) / obj->Accept(visitor2)，其中用到了visitor1和visitor2两种访问者类型，而且obj中又存放了两种类型的元素ConcreteElementA / ConcreteElementB。

：： 对象结构的遍历操作由谁负责？

若由对象结构自身负责遍历，则只需要对其包含的集合对象调用Accept()操作即可，我们通常使用这种方式；若由访问者负责遍历，那么意味着每一个具体的ConcreteVisitor都必须负责每一个具体的ConcreteElement的访问，代码复用性太差，难以维护；若由外部迭代器负责遍历，则只能使用元素类型参数，无法使用访问者类型参数，因此无法实现”Double Dispatch”。

：： 如果元素对象本身有多种，而且需要对于每种元素执行不同的操作，那么适合使用Visitor模式，这就需要在设计ConcreteVisitor时，只关注与特定类型元素相关的访问操作即可，没必要关注其他类型元素。当然了，此时抽象的Visitor中必须给出关于其他类型访问的默认实现，而不能再定义为纯虚函数。

：： 如果对象结构类很少改变，但需要经常在该结构上定义新操作，如果此时不使用Visitor模式，那么改变对象结构类时，必须重新定义所有访问者的接口，代价很大。

 

模式优缺点：

1>  Visitor模式使得新增访问操作变得非常容易，只需要增加一个ConcreteVisitor类即可。

2>  与迭代器相比，访问者模式可以访问具有不同类型元素的对象结构；而迭代器只能对同一类型的对象进行操作。

3>  增加新的ConcreteElement类很困难，必须在Visitor接口中添加对应的访问操作，同时，如果Visitor中不给出缺省的实现，那么还必须修改每一个ConcreteVisitor实现类。

4>  访问者模式要求ConcreteElement类提供的功能完全满足访问者的需求，这意味着可能需要提供访问元素内部状态的公共操作，因此会破坏封装性。