设计模式——访问者模式(Visitor)

意图：

表示一个作用于某对象结构中的各个元素的操作．它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作；

适用性：

1、一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作；

2、需要对一个对象结构中的对象进行很多不同的而且不相关的操作，而你想避免让这些操作“污染”这些对象的类．Visitor模式使得你可以把相关的操作集中起来并定义在一个类中．当该对象结构被很多应用共享时，使用Visitor模式让每个应用仅包含需要用到的操作．

3、定义对象结构的类很少改变，但是经常需要在此结构上定义新的操作．改变对象结构类需要重新定义对所有访问者的接口，这可能需要很大的代价．如果对象结构类经常改变，那么可能还是在这些类中定义这些操作比较好；

UML图：

解析：

Visitor模式把对结点的访问封装成一个抽象基类，通过派生出不同的类生成新的访问方式。在实现的时候，在visitor抽象基类中声明了对所有不同结点进行访问的接口函数，如图中的VisitConcreateElementA函数等，这样也造成了Visitor模式的一个缺陷——新加入一个结点的时候都要添加Visitor中的对其进行访问接口函数，这样使得所有的Visitor及其派生类都要重新编译了，也就是说Visitor模式一个缺点就是添加新的结点十分困难。另外，还需要指出的是Visitor模式采用了所谓的"双重分派"的技术，拿上图来作为例子，要对某一个结点进行访问，首先需要产生一个Element的派生类对象，其次要传入一个Visitor类派生类对象来调用对应的Accept函数，也就是说，到底对哪种Element采用哪种Visitor访问，需要两次动态绑定才可以确定下来，具体的实现可以参考下面实现代码中的Main.cpp部分是如何调用这些类的。

实现：

Visitor.h
#ifndef VISITOR_H
#define VISITOR_H
class Visitor;
class Element
{
public:
　　　 virtual ~Element(){}
　　　 virtual void Accept(Visitor &rVisitor) = 0;
protected:
　　　 Element(){}
};
class ConcreateElementA
　　　 : public Element
{
public:
　　　 virtual ~ConcreateElementA() {}
　　　 virtual void Accept(Visitor &rVisitor);
};
class ConcreateElementB
　　　 : public Element
{
public:
　　　 virtual ~ConcreateElementB() {}
　　　 virtual void Accept(Visitor &rVisitor);
};
class Visitor
{
public:
　　　 virtual ~Visitor(){}
　　　 virtual void VisitConcreateElementA(ConcreateElementA *pConcreateElementA) = 0;
　　　 virtual void VisitConcreateElementB(ConcreateElementB *pConcreateElementB) = 0;
protected:
　　　 Visitor(){}
};
class ConcreateVisitorA
　　　 : public Visitor
{
public:
　　　 virtual ~ConcreateVisitorA(){}
　　　 virtual void VisitConcreateElementA(ConcreateElementA *pConcreateElementA);
　　　 virtual void VisitConcreateElementB(ConcreateElementB *pConcreateElementB);
};
class ConcreateVisitorB
　　　 : public Visitor
{
public:
　　　 virtual ~ConcreateVisitorB(){}
　　　 virtual void VisitConcreateElementA(ConcreateElementA *pConcreateElementA);
　　　 virtual void VisitConcreateElementB(ConcreateElementB *pConcreateElementB);
};
#endif

Visitor.cpp
#include "Visitor.h"
#include <iostream>
void ConcreateElementA::Accept(Visitor &rVisitor)
{
　　　 rVisitor.VisitConcreateElementA(this);
}
void ConcreateElementB::Accept(Visitor &rVisitor)
{
　　　 rVisitor.VisitConcreateElementB(this);
}
void ConcreateVisitorA::VisitConcreateElementA(ConcreateElementA *pConcreateElementA)
{
　　　 std::cout << "VisitConcreateElementA By ConcreateVisitorAn";
}
void ConcreateVisitorA::VisitConcreateElementB(ConcreateElementB *pConcreateElementA)
{
　　　 std::cout << "VisitConcreateElementB By ConcreateVisitorAn";
}
void ConcreateVisitorB::VisitConcreateElementA(ConcreateElementA *pConcreateElementA)
{
　　　 std::cout << "VisitConcreateElementA By ConcreateVisitorBn";
}
void ConcreateVisitorB::VisitConcreateElementB(ConcreateElementB *pConcreateElementA)
{
　　　 std::cout << "VisitConcreateElementB By ConcreateVisitorBn";
}

Main.cpp
#include "Visitor.h"
int main()
{
　　　 Visitor *pVisitorA = new ConcreateVisitorA();
　　　 Element *pElement　 = new ConcreateElementA();
　　　 pElement->Accept(*pVisitorA);
　　　 delete pElement;
　　　 delete pVisitorA;
　　　 return 0;
}