详解C++设计模式编程中对访问者模式的运用

访问者模式（visitor），表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式适用于数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。访问者模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。反之，如果这样的系统的数据结构对象易于变化，经常要有新的数据对象增加进来，就不适合使用访问者模式。

访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。通常concreteVisitor可以单独开发，不必跟concreteElement写在一起。访问者的缺点其实也就是使增加新的数据结构变得困难了。

结构图：

访问者模式基本示例代码

访问者模式 visitor.h、concreteVisitor.h、element.h、concreteElement.h、objectStructure.h

客户端 visitorApp.cpp

访问者模式

visitor.h
/************************************************************************ 
 * description: 为该对象结构中ConcreteElement的每一个类声明一个visit操作 
 * remark:  
************************************************************************/ 
#ifndef _VISITOR_H_ 
#define _VISITOR_H_ 
class concreteElementA; 
class concreteElementB; 
class visitor 
{ 
public: 
 visitor(){}; 
 virtual ~visitor(){}; 
 virtual void visitConcreteElementA(concreteElementA* pConcreteElementA) = 0; 
 virtual void visitConcreteElementB(concreteElementB* pConcreteElementB) = 0; 
}; 
#endif// _VISITOR_H_ 

concreteVisitor.h

/************************************************************************ 
 * description: 具体访问者，实现每个由visitor声明的操作。每个操作实现算法 
    的一部分，而该算法片断乃是对应于结构中对象的类 
 * remark:  
************************************************************************/ 
#ifndef _CONCRETE_VISITOR_H_ 
#define _CONCRETE_VISITOR_H_ 
#include "visitor.h" 
#include <iostream> 
using namespace std; 
class concreteVisitor1 : public visitor 
{ 
public: 
 concreteVisitor1(){}; 
 ~concreteVisitor1(){}; 
 virtual void visitConcreteElementA(concreteElementA* pConcreteElementA) 
 { 
  cout << "concreteElementA被concreteVisitor1访问" << endl;  
 } 
 virtual void visitConcreteElementB(concreteElementB* pConcreteElementB) 
 { 
  cout << "concreteElementB被concreteVisitor1访问" << endl;   
 } 
}; 
 
class concreteVisitor2 : public visitor 
{ 
public: 
 concreteVisitor2(){}; 
 ~concreteVisitor2(){}; 
 virtual void visitConcreteElementA(concreteElementA* pConcreteElementA) 
 { 
  cout << "concreteElementA被concreteVisitor2访问" << endl;  
 } 
 virtual void visitConcreteElementB(concreteElementB* pConcreteElementB) 
 { 
  cout << "concreteElementB被concreteVisitor2访问" << endl;   
 } 
}; 
#endif// _CONCRETE_VISITOR_H_ 

element.h

/************************************************************************ 
 * description: 定义一个accept操作，它以一个访问者为参数 
 * remark:  
************************************************************************/ 
#ifndef _ELEMENT_H_ 
#define _ELEMENT_H_ 
class visitor; 
class element 
{ 
public: 
 element(){}; 
 virtual ~element(){}; 
 virtual void accept(visitor* pVisitor) = 0; 
}; 
#endif// _ELEMENT_H_ 

concreteElement.h

#ifndef _CONCRETE_ELEMENT_H_ 
#define _CONCRETE_ELEMENT_H_ 
#include "element.h" 
#include <iostream> 
using namespace std; 
class concreteElementA : public element 
{ 
public: 
 concreteElementA(){}; 
 ~concreteElementA(){}; 
 // 充分利用双分派技术，实现处理与数据结构的分离 
 virtual void accept(visitor* pVisitor) 
 { 
  if (NULL != pVisitor) 
  { 
   pVisitor->visitConcreteElementA(this); 
  } 
 } 
 // 其他的相关方法 
 void operationA() 
 { 
  cout << "具体元素A的其他相关方法" << endl; 
 } 
}; 
class concreteElementB : public element 
{ 
public: 
 concreteElementB(){}; 
 ~concreteElementB(){}; 
 // 充分利用双分派技术，实现处理与数据结构的分离 
 virtual void accept(visitor* pVisitor) 
 { 
  if (NULL != pVisitor) 
  { 
   pVisitor->visitConcreteElementB(this); 
  } 
 } 
 // 其他的相关方法 
 void operationB() 
 { 
  cout << "具体元素B的其他相关方法" << endl; 
 } 
}; 
#endif// _CONCRETE_ELEMENT_H_ 

objectStructure.h

/************************************************************************ 
 * description: 枚举元素，可以提供一个高层的接口以允许访问者访问它的元素 
 * remark:  
************************************************************************/ 
#ifndef _OBJECT_STRUCTURE_H_ 
#define _OBJECT_STRUCTURE_H_ 
#include "element.h" 
#include "visitor.h" 
#include <list> 
using namespace std; 
class objectStructure 
{ 
public: 
 void attach(element* pElement) 
 { 
  m_list.push_back(pElement); 
 } 
 void detach(element* pElement) 
 { 
  m_list.remove(pElement); 
 } 
 void accept(visitor* pVisitor) 
 { 
  list<element*>::iterator Iter; 
  for (Iter = m_list.begin(); Iter != m_list.end(); ++Iter) 
  { 
   if (NULL != *Iter) 
   { 
    (*Iter)->accept(pVisitor); 
   }    
  } 
 } 
private: 
 list<element*> m_list; 
}; 
#endif// _OBJECT_STRUCTURE_H_ 

客户端      

visitorApp.cpp

// visitorApp.cpp : 定义控制台应用程序的入口点。 
// 
#include "stdafx.h" 
#include "objectStructure.h" 
#include "concreteElement.h" 
#include "concreteVisitor.h" 
void freePtr(void* vptr) 
{ 
 if (NULL != vptr) 
 { 
  delete vptr; 
  vptr = NULL; 
 } 
} 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
 objectStructure* pObject = new objectStructure(); 
 if (NULL != pObject) 
 { 
  element* pElementA = new concreteElementA(); 
  element* pElementB = new concreteElementB(); 
  pObject->attach(pElementA); 
  pObject->attach(pElementB); 
  concreteVisitor1* pVisitor1 = NULL; 
  pVisitor1 = new concreteVisitor1(); 
  concreteVisitor2* pVisitor2 = NULL; 
  pVisitor2 = new concreteVisitor2(); 
  pObject->accept(pVisitor1); 
  pObject->accept(pVisitor2); 
  system("pause"); 
  freePtr(pVisitor2); 
  freePtr(pVisitor1); 
  freePtr(pElementB); 
  freePtr(pElementA); 
  freePtr(pObject); 
 } 
 return 0; 
} 

使用访问者模式的优点和缺点

访问者模式有如下的优点：

• 访问者模式使得增加新的操作变得很容易。如果一些操作依赖于一个复杂的结构对象的话，那么一般而言，增加新的操作会很复杂。而使用访问者模式，增加新的操作就意味着增加一个新的访问者类，因此，变得很容易。
• 访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。
• 访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。迭代子只能访问属于同一个类型等级结构的成员对象，而不能访问属于不同等级结构的对象。访问者模式可以做到这一点。
• 积累状态。每一个单独的访问者对象都集中了相关的行为，从而也就可以在访问的过程中将执行操作的状态积累在自己内部，而不是分散到很多的节点对象中。这是有益于系统维护的优点。

访问者模式有如下的缺点：

• 增加新的节点类变得很困难。每增加一个新的节点都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作。
• 破坏封装。访问者模式要求访问者对象访问并调用每一个节点对象的操作，这隐含了一个对所有节点对象的要求：它们必须暴露一些自己的操作和内部状态。不然，访问者的访问就变得没有意义。由于访问者对象自己会积累访问操作所需的状态，从而使这些状态不再存储在节点对象中，这也是破坏封装的。

访问者模式的适用场景：

• 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。Vi s i t o r 使得你可以将相关的操作集中起来定义在一个类中。当该对象结构被很多应用共享时，用Vi s i t o r 模式让每个应用仅包含需要用到的操作。
• 定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。