访问者模式

【1】什么是访问者模式？

今天学习访问者模式，访问者模式是A对象访问B对象的一种模式。非也。

那么，何谓访问者模式呢？真难理解！因为这个名字就TMD超晦涩，让人听不懂，或许只是此名称本身有且仅有的一个抽象意义而已。

何谓抽象意义呢？如果你理解了《类的概念》大概你才会有所参透。

我一直理解：抽象是多态的爸爸。怎么解释呢？你想想：

类都是超级抽象的，而经由父类（即基类）衍生的子类（即派生类）就是 “多态” 的全部内在意义。

访问者模式，其实没那么复杂（呵呵！或许窃理解有误）。模式即一种做法，所以一句话概述：

把数据信息和操作行为各自分开处理而不放在一坨的做法。（要不，谁访问谁呀？你先琢磨琢磨。）

【2】访问者模式代码示例：

代码示例1（一般写法）：

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

class Person
{
public:
    string action;
    virtual void getConclusion() = 0;
};

class Man : public Person
{
public:
    void getConclusion()
    {
        if (action == "成功")
        {
            cout << "男人成功时，背后多半有一个伟大的女人。" << endl;
        }
        else if (action == "恋爱")
        {
            cout << "男人恋爱时，凡事不懂装懂。" << endl;
        }
    }
};

class Woman : public Person
{
public:
    void getConclusion()
    {
        if (action == "成功")
        {
            cout << "女人成功时，背后多半有失败的男人。" << endl;
        }
        else if (action == "恋爱")
        {
            cout << "女人恋爱时，遇到事懂也装不懂。" << endl;
        }
    }
};

void main()
{
    list<Person*> persons;

    Person *pMan1 = new Man();
    pMan1->action = "成功";
    persons.push_back(pMan1);

    Person *pWoman1 = new Woman();
    pWoman1->action = "成功";
    persons.push_back(pWoman1);

    Person *pMan2 = new Man();
    pMan2->action = "恋爱";
    persons.push_back(pMan2);

    Person *pWoman2 = new Woman();
    pWoman2->action = "恋爱";
    persons.push_back(pWoman2);

    list<Person*>::iterator iter = persons.begin();
    while (iter != persons.end())
    {
        (*iter++)->getConclusion();
    }
}
//Result:
/*
男人成功时，背后多半有一个伟大的女人。
女人成功时，背后多半有失败的男人。
男人恋爱时，凡事不懂装懂。
女人恋爱时，遇到事懂也装不懂。
*/

代码示例2（访问者模式写法）：

#include <iostream>
#include <list>
#include <string>
using namespace std;
 
class Man;
class Woman;

class Action
{
public:
    virtual void getManConclusion(Man *) = 0;
    virtual void getWomanConclusion(Woman *) = 0;
}; 

class Success : public Action
{
    void getManConclusion(Man *)
    {
        cout << "男人成功时，背后多半有一个伟大的女人" << endl;
    }
    void getWomanConclusion(Woman *)
    {
        cout << "女人成功时，背后多半有不成功的男人" << endl;
    }

};

class Love : public Action
{
    void getManConclusion(Man *)
    {
        cout << "男人恋爱时，凡事不懂装懂" << endl;
    }
    void getWomanConclusion(Woman *)
    {
        cout << "女人恋爱时，凡事懂也装不懂" << endl;
    }
};

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

class Man : public Person
{
public:
    void accept(Action* visitor)
    {
        visitor->getManConclusion(this);
    }
};

class Woman : public Person
{
public:
    void accept(Action* visitor)
    {
        visitor->getWomanConclusion(this);
    }
};

class ObjectStructure
{
private:
    list<Person*> elements;

public:
    void attach(Person* element)
    {
        elements.push_back(element);
    }
    void detach(Person* element)
    {
        for (list<Person*>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
        {
            if ((*iter) == element)
            {
                elements.erase(iter);
            }
        }
    }
    void display(Action *visitor)
    {
        for (list<Person*>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
        {
            (*iter)->accept(visitor);
        }
    }
};

int main()
{
    ObjectStructure objStructure;
    Success *os = new Success();
    Love *lv = new Love();

    Person *man = new Man();
    objStructure.attach(man);
     
    Person *woman = new Woman();
    objStructure.attach(woman);

    objStructure.display(os);
    objStructure.display(lv);

    return 0;
}
//Result:
/*
男人成功时，背后多半有一个伟大的女人
女人成功时，背后多半有不成功的男人
男人恋爱时，凡事不懂装懂
女人恋爱时，凡事懂也装不懂
*/

 【3】访问者模式角色分析

在访问者模式中，主要包括下面几个角色：

抽象访问者：一般为抽象类或者接口（如上例Action），声明访问者可以访问哪类元素。

　　　　　　具体到程序中就是visit方法中的参数定义哪些类型的元素是可以被访问的。

访问者：实现抽象访问者所声明的方法（如上例Success，Love），它影响到访问者具体访问到一种元素后该干什么，要做什么事情。

抽象元素类（被访问者）：一般为抽象类或者接口（如上例Person），声明接受哪一类访问者访问，程序上是通过accept方法中的参数来定义的。

　　　　　　抽象元素一般有两类方法，一部分是本身的业务逻辑，另外就是允许接收哪类访问者来访问。

元素类（被访问者）：实现抽象元素类所声明的accept方法（如上例Man，Woman），通常都是以this指针为实参，基本上已经形成一种定式。

元素对象（被访问者）容器：一个元素的容器（如上例ObjectStructure），一般包含一个容纳多个不同类、不同接口的容器，如List、Set、Map等，在项目中一般很少抽象出这个角色。

【4】访问者模式总结

应用情景：访问者模式适用于数据结构稳定的系统。实质上把数据结构和作用于数据结构上的操作分离开。

因为访问者模式使得算法操作增加变得更容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。

优点：新增加操作很容易，因为新增加操作相当于增加一个访问者。

由以上示例可以得知：访问者模式将有限的行为操作（访问者）集中到有限个数据结构（访问者）对象上。

比如，我们现在需求再增加一个“失败”的操作。只需要继承自Action再实现一个所谓的 “失败” 访问者即可。

 

Good  Good   Study,  Day  Day   Up.

顺序  选择   循环  总结