访问者模式
#include <iostream>using namespace std;class Element;
class Visitor
{public:
virtual ~Visitor(){}
virtual void visitConElemA(Element* elm)=0;
virtual void visitConElemB(Element* elm)=0;
protected:
Visitor(){}
};class ConcreteVisitorA:public Visitor
{public:
ConcreteVisitorA(){};
virtual ~ConcreteVisitorA(){};
void visitConElemA(Element* elm){cout<<"visit A";}
void visitConElemB(Element* elm){cout<<"visit B";}
};class ConcreteVisitorB:public Visitor
{public:
ConcreteVisitorB(){};
virtual ~ConcreteVisitorB(){};
void visitConElemA(Element* elm){cout<<"visit A";}
void visitConElemB(Element* elm){cout<<"visit B";}
};class Element
{public:
virtual ~Element(){};
virtual void Accept(Visitor* vis)=0;
protected:
Element(){};
};class ConcreteElementA:public Element
{public:
ConcreteElementA(){}
~ConcreteElementA(){}
void Accept(Visitor* vis)
{
cout<<"This is A interface "<<endl; vis-="">visitConElemA(this);
}
};class ConcreteElementB:public Element
{public:
ConcreteElementB(){}
~ConcreteElementB(){}
void Accept(Visitor* vis)
{
cout<<"This is B interface ";
vis->visitConElemB(this);
}
};void main()
{ Visitor* vis=new ConcreteVisitorA();
Element* elm=new ConcreteElementA();
elm->Accept(vis);
delete elm;
delete vis;
} |
1 主要优点
（1）增加新的访问操作十分方便， 符合开闭原则
（2）将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中，类的职责更加清晰 => 符合单一职责原则
2 主要缺点
（1）增加新的元素类很困难，需要在每一个访问者类中增加相应访问操作代码 => 违背了开闭原则
（2）元素对象有时候必须暴露一些自己的内部操作和状态，否则无法供访问者访问 => 破坏了元素的封装性
3 应用场景
（1）一个对象结构包含多个类型的对象，希望对这些对象实施一些依赖其具体类型的操作。=> 不同的类型可以有不同的访问操作
（2）对象结构中对象对应的类很少改变 很少改变 很少改变（重要的事情说三遍），但经常需要在此对象结构上定义新的操作。