C++设计模式——访问者模式

1. 访问者模式

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

访问者模式适用于数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间耦合解脱开，使得操作几何可以相对自由地演化。

2. 场景举例

visitor.h

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

class Visitor;

// 被访问元素: 定义一个Accept操作，它以一个访问者为参数
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;
};

//具体元素A:实现Accept操作，该操作以一个访问者为参数
class ConcreteElementA : public Element
{
public:
	ConcreteElementA(std::string str) : Element(str) {}
	void Accept(Visitor * visitor);
};

//具体元素B
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;
};

//具体访问者A
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;
	}
};

//具体访问者B
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;
	}
};

// 聚集类对象结构:能够枚举它的元素，同时提供一个高层的接口以允许该访问者访问它的元素
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);
		}
	}
};

visitor.cpp

#include "stdafx.h"
#include "Visitor.h"

void ConcreteElementA::Accept(Visitor * visitor)
{
	visitor->VisitConcreteElementA(this);
}
void ConcreteElementB::Accept(Visitor * visitor)
{
	visitor->VisitConcreteElementB(this);
}

main.cpp

int main()
{
	// 访问者模式
	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;
	return 0;
}

运行结果：

3. 结论

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