设计模式之访问者模式

介绍

• Visitor——抽象访问者
  抽象类或者接口， 声明访问者可以访问哪些元素， 具体到程序中就是visit方法的参数定义哪些对象是可以被访问的。
• ConcreteVisitor——具体访问者
  它影响访问者访问到一个类后该怎么干， 要做什么事情。
• Element——抽象元素
  接口或者抽象类， 声明接受哪一类访问者访问， 程序上是通过accept方法中的参数来定义的。
• ConcreteElement——具体元素
  实现accept方法， 通常是visitor.visit(this)， 基本上都形成了一种模式了。
• ObjectStruture——结构对象
  元素产生者， 一般容纳在多个不同类、 不同接口的容器， 如List、 Set、 Map等， 在项目中， 一般很少抽象出这个角色

优点：符合单一职责原则；优秀的扩展性；灵活性非常高

缺点：具体元素对访问者公布细节；具体元素变更比较困难； 违背了依赖倒置转原则

应用：

• 一个对象结构包含很多类对象， 它们有不同的接口， 而你想对这些对象实施一些依赖于其具体类的操作，也就说是用迭代器模式已经不能胜任的情景
• 需要对一个对象结构中的对象进行很多不同并且不相关的操作， 而你想避免让这些操作“污染”这些对象的类

UML类图：

简单代码：

#ifndef SIMPLE_VISITOR_H
#define SIMPLE_VISITOR_H
#include <iostream>
#include <typeinfo>
#include <list>
using namespace std;

class Visitor;

class Element
{
public:
    virtual void accept(Visitor *visitor) = 0;
};

class ConcreteElementA;
class ConcreteElementB;

/**
 * @brief The Visitor class
 * Visitor类，为该对象结构中ConcreteElement的每一个类声明一个Visit操作。
 */
class Visitor
{
public:
    virtual void visitConcreteElementA(ConcreteElementA *ceA) = 0;
    virtual void visitConcreteElementB(ConcreteElementB *ceB) = 0;
};


/**
 * @brief The ConcreteVisitor1 class
 * ConcreteVisitor1，具体访问者，实现每个由Visitor 声明的操作。每个操作实
 * 现算法的一.部分，而该算法片断乃是对应于结构中对象的类。
 */
class ConcreteVisitor1: public Visitor
{
public:
    void visitConcreteElementA(ConcreteElementA *ceA) override
    {
        cout<<"["<<typeid(ceA).name()<<"] 被 ["<<typeid (this).name()<<"] 访问"<<endl;
    }

    void visitConcreteElementB(ConcreteElementB *ceB) override
    {
        cout<<"["<<typeid(ceB).name()<<"] 被 ["<<typeid (this).name()<<"] 访问"<<endl;
    }
};

/**
 * @brief The ConcreteVisitor1 class
 * ConcreteVisitor2，具体访问者，实现每个由Visitor 声明的操作。每个操作实
 * 现算法的一部分，而该算法片断乃是对应于结构中对象的类。
 */
class ConcreteVisitor2: public Visitor
{
public:
    void visitConcreteElementA(ConcreteElementA *ceA) override
    {
        cout<<"["<<typeid(ceA).name()<<"] 被 ["<<typeid (this).name()<<"] 访问"<<endl;
    }

    void visitConcreteElementB(ConcreteElementB *ceB) override
    {
        cout<<"["<<typeid(ceB).name()<<"] 被 ["<<typeid (this).name()<<"] 访问"<<endl;
    }
};



class ConcreteElementA : public Element
{
public:
    void accept(Visitor *visitor) override
    {
        visitor->visitConcreteElementA(this);
    }

    void operationA()
    {
        cout<<"operationA"<<endl;
    }
};

class ConcreteElementB: public Element
{
public:
    void accept(Visitor *visitor) override
    {
        visitor->visitConcreteElementB(this);
    }

    void operationB()
    {
        cout<<"operationB"<<endl;
    }
};






class ObjectStructure
{
public:
    ObjectStructure()
    {
        m_list.clear();
    }

    void attach(Element *ele)
    {
        m_list.push_back(ele);
    }

    void detach(Element *ele)
    {
        m_list.remove(ele);
    }

    void accept(Visitor *vis)
    {
        for (list<Element*>::iterator it=m_list.begin() ; it != m_list.end();  it++) {
            (*it)->accept(vis);

        }
    }
private:
    list<Element*> m_list;
};

#endif // SIMPLE_VISITOR_H

 大话设计模式第28章，男人和女人的例子

UML图：

代码：

#ifndef MAN_WOMEN_VISITOR_H
#define MAN_WOMEN_VISITOR_H

#include <iostream>
#include <typeinfo>
#include <list>
using namespace std;

class Action;

class Men;
class Women;

class Person
{
public:
    virtual void accept(Action *act) = 0;
};



class Action
{
public:
    virtual void getMenConclusion(Men *men) = 0;
    virtual void getWomenConclusion(Women *women) = 0;
};

class Men : public Person
{
public:
    void accept(Action *act) override
    {
        act->getMenConclusion(this);
    }
};

class Women : public Person
{
public:
    void accept(Action *act) override
    {
        act->getWomenConclusion(this);
    }
};



class Success : public Action
{
public:
    void getMenConclusion(Men *men) override
    {
        cout<<" [ "<<typeid(men).name()<<"] ["<<typeid(this).name()<<" ]时，背后多半有一个伟大的女人"<<endl;
    }

    void getWomenConclusion(Women *women) override
    {
        cout<<" [ "<<typeid(women).name()<<"] ["<<typeid(this).name()<<" ]时，背后大多有一个不成功的男人"<<endl;
    }

};



class Failing : public Action
{
public:
    void getMenConclusion(Men *men) override
    {
        cout<<" [ "<<typeid(men).name()<<"] ["<<typeid(this).name()<<" ]时，闷头喝酒，谁也不用劝。"<<endl;
    }

    void getWomenConclusion(Women *women) override
    {
        cout<<" [ "<<typeid(women).name()<<"] ["<<typeid(this).name()<<" ]时，眼泪汪汪，谁也劝不了。"<<endl;
    }

};

class Amativeness : public Action
{
public:
    void getMenConclusion(Men *men) override
    {
        cout<<" [ "<<typeid(men).name()<<"] ["<<typeid(this).name()<<" ]时，凡事不懂也要装懂。"<<endl;
    }

    void getWomenConclusion(Women *women) override
    {
        cout<<" [ "<<typeid(women).name()<<"] ["<<typeid(this).name()<<" ]时，遇事懂也装作不懂。"<<endl;
    }

};



class ObjectMenWomen
{
public:
    ObjectMenWomen()
    {
        m_list.clear();
    }

    void attach(Person *ele)
    {
        m_list.push_back(ele);
    }

    void detach(Person *ele)
    {
        m_list.remove(ele);
    }

    void display(Action *vis)
    {
        for (list<Person*>::iterator it=m_list.begin() ; it != m_list.end();  it++) {
            (*it)->accept(vis);

        }
    }
private:
    list<Person*> m_list;
};


#endif // MAN_WOMEN_VISITOR_H