设计模式--访问者设计模式

Gof定义

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

动机

在软件构建过程中，由于需求的改变，某些类层次结构中常常需要增加新的行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有设计。如何在不更改类层次结构的前提下，在运行时根据需要透明地为类层次结构上的各个类动态添加新的操作，从而避免上述问题？请看下面访问者模式结构图和代码。

访问者模式结构图：





Visitor和Element肯定都是抽象类，或者接口了；这样可以定义不同类型的Visitor，不同类型的Element，并且都提供统一的对外接口。

Element既然是被访问者，要有一个对外方法接受访问，一般定义为accept()方法，当然接受的参数是Visitor类型的对象了；在accept方法内部，Visitor要对Element进行访问，最好的方法就是把自己this传给Visitor的方法（如果要是在accept方法中直接进行具体的操作的话，那就不是Visitor对Element访问，而是Element自己对自己的访问了）；Visitor的这个方法一般叫做visit（），方法并且接受的参数是Element类型；在Visitor的visit方法中，根据不同的Element类型进行不同的操作。

在程序员看来，首先Visitor传给了Element，之后Element又传给了Visitor；于是某些爱整概念的老家伙们把这样的一个“技术”，美其名曰：双分配技术。

实现的C++代码如下:

#include <iostream>
#include <vector>
using namespace std;

class ConcreteElementA;
class ConcreteElementB;

//抽象访问者类 ,定义了两个统一的接口visitConcreteElementA()和visitConcreteElementB()
class visitor
{
public:
virtual void visitConcreteElementA(ConcreteElementA& ) = 0;
virtual void visitConcreteElementB(ConcreteElementB& ) = 0;
};

//抽象被访问对象类，定义了一个统一的接口Accept()
class Element
{
public:
virtual void Accept(visitor& ) = 0;
};
//具体被访问类A，实现了Accept（）函数，接收一个visitor，在该函数中把 自己传递给visitor
class ConcreteElementA: public Element
{
public:
void Accept(visitor& V)
{
V.visitConcreteElementA(*this);
}
void OperationA()
{
cout << " ConcreteElementA::OperationA() " << endl;
}
};
//集体被访问类B
class ConcreteElementB : public Element
{
public:
void Accept(visitor& V)
{
V.visitConcreteElementB(*this);
}
void OperationB()
{
cout <<" ConcreteElementB::OperatrionB() " << endl;;
}
};

//具体访问者类A
class ConcreteVisitor1: public visitor
{
public:
void visitConcreteElementA(ConcreteElementA & A)
{
cout << "ConcreteVisitor1::visitConcreteElemtnA" << endl;
A.OperationA();
}
void visitConcreteElementB(ConcreteElementB & B)
{
cout << "ConcreteVisitor1::visitConcreteElemtnB" << endl;
B.OperationB();
}
};
//具体访问者类B
class ConcreteVisitor2: public visitor
{
public:
void visitConcreteElementA(ConcreteElementA & A)
{
cout << "ConcreteVisitor2::visitConcreteElemtnA" << endl;
A.OperationA();
}
void visitConcreteElementB(ConcreteElementB & B)
{
cout << "ConcreteVisitor2::visitConcreteElemtnB" << endl;
B.OperationB();
}
};

class ObjectStructure
{
private:
vector<Element*> Elementlist;

public:
void add(Element* E)
{
Elementlist.push_back(E);
}

void Accept(visitor & v)
{
for(vector<Element*>::iterator i = Elementlist.begin(); i!= Elementlist.end(); i++)
{
(*i)->Accept(v);
}
}

};

int main()
{
ObjectStructure list;
list.add(new ConcreteElementA());
list.add(new ConcreteElementB());
list.add(new ConcreteElementA());
list.add(new ConcreteElementB());

visitor* v1 = new ConcreteVisitor1();
visitor* v2 = new ConcreteVisitor2();
list.Accept(*v1);
list.Accept(*v2);

system("pause");
return 0;
}

参考引用：

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/secondsquare/archive/2009/06/06/4247324.aspx

http://oec2003.cnblogs.com/