设计模式之访问者模式（C++）

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

其UML图如下：

每个ConcreteVisitor都有自己的数据处理方式，但是它们处理的数据则是不变的。在ObjectStucture中有Element的列表，并提供了访问数据的接口。

示例代码如下：

// VisitorModel.h文件
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

class Visitor;
// 被访问元素
class Element
{
protected: 
	std::string m_strName;
public:
	Element(std::string str)
	{
		m_strName = str;
	}
	std::string getName()
	{
		return m_strName;
	}
	virtual void Accept(Visitor * visitor) = 0;
};

class ConcreteElementA : public Element
{
public:
	ConcreteElementA(std::string str) : Element(str) {}
	void Accept(Visitor * visitor);
};

class ConcreteElementB : public Element
{
public: 
	ConcreteElementB(std::string str) : Element(str) {}
	void Accept(Visitor * visitor);
};

// 访问者
class Visitor
{
public:
	virtual void VisitConcreteElementA(ConcreteElementA * p) = 0;
	virtual void VisitConcreteElementB(ConcreteElementB * p) = 0;
};

class ConcreteVisitorA : public Visitor
{
public:
	void VisitConcreteElementA(ConcreteElementA * p)
	{
		std::cout << "ConcreteVisitorA 访问了" << p->getName() << std::endl;
	}
	void VisitConcreteElementB(ConcreteElementB * p)
	{
		std::cout << "ConcreteVisitorA 访问了" << p->getName() << std::endl;
	}
};

class ConcreteVisitorB : public Visitor
{
public:
	void VisitConcreteElementA(ConcreteElementA * p)
	{
		std::cout << "ConcreteVisitorB 访问了" << p->getName() << std::endl;
	}
	void VisitConcreteElementB(ConcreteElementB * p)
	{
		std::cout << "ConcreteVisitorB 访问了" << p->getName() << std::endl;
	}
};

void ConcreteElementA::Accept(Visitor * visitor)
{
	visitor->VisitConcreteElementA(this);
}
void ConcreteElementB::Accept(Visitor * visitor)
{
	visitor->VisitConcreteElementB(this);
}
// 聚集类
class ObjectStructure
{
private:
	std::vector<Element *> m_vec;
public:
	~ObjectStructure()
	{
		for (auto it = m_vec.begin(); it != m_vec.end(); it++)
		{
			delete *it;
		}
		m_vec.clear();
	}
	void add(Element * p)
	{
		m_vec.push_back(p);
	}
	void accept(Visitor * visitor)
	{
		for (auto it = m_vec.cbegin(); it != m_vec.cend(); it++)
		{
			(*it)->Accept(visitor);
		}
	}
};

测试代码如下：

#include <iostream>
#include "VisitorModel.h"

int main()
{
	using namespace std;
	// 访问者模式
	ObjectStructure * p = new ObjectStructure();
	p->add(new ConcreteElementA("A"));
	p->add(new ConcreteElementB("B"));

	ConcreteVisitorA * pVisitorA = new ConcreteVisitorA();
	ConcreteVisitorB * pVisitorB = new ConcreteVisitorB();

	p->accept(pVisitorA);
	p->accept(pVisitorB);

	delete pVisitorA;
	delete pVisitorB;
	delete p;

	getchar();
	return 0;
}

测试结果如下图：

访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。