访问者模式

#include <list>
using std::list;
using namespace std;
/*需要对一个对象中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作‘污染’这些对象的类。

   visitor使得你可以将相关的操作集中起来定义在一个类中，分离了类的内部元素与访问它们的操作,做到数据和访问的分离*/
class Element;
class EleA;
class EleB;
//对元素操作的访问者
class visitor{
  //friend class Element;
public:
 visitor(){}
 //为每一个具体元素定义一个visitor操作
 virtual void visitorEleA(Element *A){}
 virtual void visitorEleB(Element *B){}
};
//元素
class Element{
 friend class visitor;
public:
     //接受访问时，访问者针对不同类调用不同访问函数
 virtual void Accept(visitor * v){}
};
class concreatevisitor1 :public visitor{
public:
friend class EleA;
friend class EleB;
 concreatevisitor1(){}
 void visitorEleA(EleA *A)
 {
   //  A->Accept(this); C++ 仅支持单分派
      cout<<"A->Accept(concreatevisitor1)"<<endl;
 }
 void visitorEleB(EleB *B)
 {
    // B->Accept(this);
  cout<<"B->Accept(concreatevisitor1)"<<endl;
 }
};
class concreatevisitor2 :public visitor{
friend class EleA;
friend class EleB;
public:
 concreatevisitor2(){}
 void visitorEleA(EleA *A)
 {
 // A->Accept(this);
  cout<<"A->Accept(concreatevisitor2)"<<endl;
 }
 void visitorEleB(EleB *B)
 {
 // B->Accept(this);
  cout<<"B->Accept(concreatevisitor2)"<<endl;
 }
};

class ObjectStruct{
public:
 void Attach(Element * e)
 {
  listofElements.push_back(e);
 }
 void Dettach()
 {
  listofElements.pop_front();
 }
 void Accept(visitor * v)
 {
  for(std::list<Element*>::iterator it=listofElements.begin();it!=listofElements.end();it++)
   (*it)->Accept(v);
 }
private:
 list<Element*> listofElements;
};

class EleA :public Element{
 friend class concreatevisitor1;
 friend class concreatevisitor2;
public:
 void Accept(concreatevisitor1 * v1)
 {
  v1->visitorEleA(this);
 }
 void Accept(concreatevisitor2 * v2)
 {
  v2->visitorEleA(this);
 }
};

class EleB :public Element{
 friend class concreatevisitor1;
 friend class concreatevisitor2;
public:
 void Accept(concreatevisitor1 * v1)
 {
  v1->visitorEleB(this);
 }
 void Accept(concreatevisitor2 * v2)
 {
  v2->visitorEleB(this);
 }
};