Visitor Pattern

1.Visitor模式：将更新（变更）封装到一个类中（访问操作），并由待更改类提供一个接收接口，则可在不破坏类的前提下，为类提供增加新的新操作。

2.Visitor模式结构图

Visitor模式的关键是双分派（Double-Dispatch）的技术：Accept（）操作是一个双分派的操作，具体调用哪个Accept（）操作，有两个决定因素（1）Element类型（2）Visitor类型。

3.实现

 #ifndef _VISITOR_H_

 #define _VISITOR_H_ 

 class Element; 

 class Visitor

 {

 public:

     virtual ~Visitor();

     virtual void VisitConcreteElementA(Element* elm) = ;

     virtual void VisitConcreteElementB(Element* elm) = ;

 protected:

     Visitor();

 private:

 };

 class ConcreteVisitorA:public Visitor

 {

 public:

     ConcreteVisitorA();

     virtual ~ConcreteVisitorA();

     virtual void VisitConcreteElementA(Element* elm);

     virtual void VisitConcreteElementB(Element* elm);

 protected:

 private:

 }; 

 class ConcreteVisitorB:public Visitor

 {

 public:

     ConcreteVisitorB();

     virtual ~ConcreteVisitorB();

     virtual void VisitConcreteElementA(Element* elm);

     virtual void VisitConcreteElementB(Element* elm);

 protected:

 private:

 }; 

 #endif

Visitor.h

 #include "Visitor.h"

 #include "Element.h"

 #include <iostream>

 using namespace std;

 Visitor::Visitor()

 {

 }

 Visitor::~Visitor()

 {

 }

 ConcreteVisitorA::ConcreteVisitorA()

 {

 }

 ConcreteVisitorA::~ConcreteVisitorA()

 {

 }

 void ConcreteVisitorA::VisitConcreteElementA(Element* elm)

 {

     cout<<"i will visit ConcreteElementA..."<<endl;

 }

 void ConcreteVisitorA::VisitConcreteElementB(Element* elm)

 {

     cout<<"i will visit ConcreteElementB..."<<endl;

 }

 ConcreteVisitorB::ConcreteVisitorB()

 {

 }

 ConcreteVisitorB::~ConcreteVisitorB()

 {

 }

 void ConcreteVisitorB::VisitConcreteElementA(Element* elm)

 {

     cout<<"i will visit ConcreteElementA..."<<endl;

 }

 void ConcreteVisitorB::VisitConcreteElementB(Element* elm)

 {

     cout<<"i will visit ConcreteElementB..."<<endl;

 }

Visitor.cpp

 #ifndef _ELEMENT_H_

 #define _ELEMENT_H_ 

 class Visitor; 

 class Element

 {

 public:

     virtual ~Element();

     virtual void Accept(Visitor* vis) = ;

 protected:

     Element();

 private:

 }; 

 class ConcreteElementA:public Element

 {

 public:

     ConcreteElementA();

     ~ConcreteElementA();

     void Accept(Visitor* vis);

 protected:

 private:

 }; 

 class ConcreteElementB:public Element

 {

 public:

     ConcreteElementB();

     ~ConcreteElementB();

     void Accept(Visitor* vis);

 protected:

 private:

 }; 

 #endif

Element.h

 #include "Element.h"

 #include "Visitor.h"

 #include <iostream>

 using namespace std; 

 Element::Element()

 {

 }

 Element::~Element()

 {

 }

 void Element::Accept(Visitor* vis)

 {

 }

 ConcreteElementA::ConcreteElementA()

 {

 }

 ConcreteElementA::~ConcreteElementA()

 {

 }

 void ConcreteElementA::Accept(Visitor* vis)

 {

     vis->VisitConcreteElementA(this);

     cout<<"visiting ConcreteElementA..."<<endl;

 }

 ConcreteElementB::ConcreteElementB()

 {

 }

 ConcreteElementB::~ConcreteElementB()

 {

 }

 void ConcreteElementB::Accept(Visitor* vis)

 {

     cout<<"visiting ConcreteElementB..."<<endl;

     vis->VisitConcreteElementB(this);

 }

Element.cpp

 #include "Element.h"

 #include "Visitor.h"

 #include <iostream>

 using namespace std; 

 int main(int argc,char* argv[])

 {

     Visitor* vis = new ConcreteVisitorA();

     Element* elm = new ConcreteElementA();

     elm->Accept(vis); 

     return ;

 }

main.cpp

4.Visitor模式的缺点

（1）破坏了封装性

（2）ConcreteElement的扩展很困难：每增加一个Element的子类，就要修改Visitor的接口，使得可以提供给这个新增加的子类的访问机制。

巴特西

Visitor Pattern

最新文章

热门文章