访问者模式（Visitor）

背景
在软件构件过程中，由于需求的改变，某些类层次结构中常常需要增加新的行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有设计。
如何在不更改层次结构的前提下，在运行时根据需要透明地为类层次结构上的各个类动态添加新的操作，从而避免上诉问题？
解决方法
表示一个用于某对象结构中的各元素的操作。使得可以在不改变（稳定）各元素的前提下定义（扩展）作用于这些元素的新操作（变化）。
特点
Visitor模式通过所谓双重分发来实现不在更改（不添加新的操作-编译时）Element类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作（支持变化）。
所谓双重分发即Visitor模式中间包括了两个多态分发：第一个为accept方法的多态辨析，第二个为VisitConcreteElementA，VisitConcreteElementB的多态辨析。
缺点
在于扩展类层次结构（添加新的Element子类），会导致Visitor类的改变。因此Visitor模式适用于“Element类层次结构稳定，而其中的操作经常面临频繁改动”。
代码实现

//Element.h
#pragma once
class Visitor;
class Element {
public:
	virtual ~Element();
	virtual void accpect(Visitor* vistor) = 0;
protected:
	Element();
};
class ConcreteElementA :public Element {
public:
	ConcreteElementA();
	~ConcreteElementA();
	void accpect(Visitor* vistor);
};
class ConcreteElementB :public Element {
public:
	ConcreteElementB();
	~ConcreteElementB();
	void accpect(Visitor* vistor);
};
//Element.cpp
#include"Element.h"
#include"Visitor.h"
Element::Element() {

}
Element::~Element() {

}
ConcreteElementA::ConcreteElementA() {

}
ConcreteElementA::~ConcreteElementA() {

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

}
ConcreteElementB::~ConcreteElementB() {

}
void ConcreteElementB::accpect(Visitor* visitor) {
	visitor->VisitConcreteElementB(this);
}
//Visitor.h
#pragma once
class Element;
class Visitor {
public:
	virtual ~Visitor();
	virtual void VisitConcreteElementA(Element* element) = 0;
	virtual void VisitConcreteElementB(Element* element) = 0;
protected:
	Visitor();
};
class ConcreteVisitorA :public Visitor {
public:
	ConcreteVisitorA();
	~ConcreteVisitorA();
	void VisitConcreteElementA(Element* element);
	void VisitConcreteElementB(Element* element);
};
class ConcreteVisitorB :public Visitor {
public:
	ConcreteVisitorB();
	~ConcreteVisitorB();
	void VisitConcreteElementA(Element* element);
	void VisitConcreteElementB(Element* element);
};
//Visitor.cpp
#include"Visitor.h"
#include<iostream>
Visitor::Visitor() {

}
Visitor::~Visitor() {

}
ConcreteVisitorA::ConcreteVisitorA() {

}
ConcreteVisitorA::~ConcreteVisitorA() {

}
void ConcreteVisitorA::VisitConcreteElementA(Element* element) {
	std::cout << "ConcreteVisitorA::VisitConcreteElementA" << std::endl;
}
void ConcreteVisitorA::VisitConcreteElementB(Element* element) {
	std::cout << "ConcreteVisitorA::VisitConcreteElementB" << std::endl;
}
ConcreteVisitorB::ConcreteVisitorB() {

}
ConcreteVisitorB::~ConcreteVisitorB() {

}
void ConcreteVisitorB::VisitConcreteElementA(Element* element) {
	std::cout << "ConcreteVisitorB::VisitConcreteElementA" << std::endl;
}
void ConcreteVisitorB::VisitConcreteElementB(Element* element) {
	std::cout << "ConcreteVisitorB::VisitConcreteElementB" << std::endl;
}
//Main.cpp
#include"Element.h"
#include"Visitor.h"
int main() {
	Element* elementa = new ConcreteElementA();
	Visitor* visitora = new ConcreteVisitorA();
	Visitor* visitorb = new ConcreteVisitorB();
	elementa->accpect(visitora);
	elementa->accpect(visitorb);
	Element* elementb = new ConcreteElementB();
	elementb->accpect(visitora);
	elementb->accpect(visitorb);
	delete visitora;
	delete visitorb;
	delete elementa;
	delete elementb;
	return 0;
}

运行截图