访问者模式（visitor）c++版本（设计模式完）

这是大话设计模式中的访问者模式的c++版本

/*
 * visitor.cpp
 *
 *  Created on: Nov 16, 2017
 *      Author: clh01s@163.com
 *      访问者模式：表示一个作用于某对象结构中的各个元素的操作。
 *                它使你可以在不改变各个元素的类的前提下定义
 *                作用于这些元素的新操作。
 */

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Man;
class Woman;

//状态的抽象类
class Action
{
public:
    virtual ~Action(){}
    virtual void GetManConclusion(Man* concreteElement)=0;
    virtual void GetWomanConclusion(Woman* concreteElement)=0;
};

//男人女人的抽象类
class Person
{
public:
    virtual ~Person(){}
    //获得状态对象
    virtual void Accept(Action* visitor)=0;
};

class Man:public Person
{
public:
    //实现基类虚函数
    void Accept(Action* visitor) override
    {
        /* 首先在客户程序中将具体状态作为参数传递给
         * “男人”类完成了一次分派，然后“男人”类调
         * 用作为参数的“具体状态”中的方法“男人反应”
         * 同时将自己（this）作为参数传递进去，完成
         * 了二次分派。
         */
        visitor->GetManConclusion(this);
    }
    string GetGender(){return _gender;}
private:
    string _gender = "男人";
};

class Woman:public Person
{
public:
    //实现基类虚函数
    void Accept(Action* visitor) override
    {
        visitor->GetWomanConclusion(this);
    }
    string GetGender(){return _gender;}
private:
    string _gender = "女人";
};

//成功
class Success:public Action
{
public:
    void GetManConclusion(Man* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"成功时，背后多半有个伟大的女人。"<<endl;
    }

    void GetWomanConclusion(Woman* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"成功时，背后多半有个不成功的男人。"<<endl;
    }

};

//失败
class Failing:public Action
{
public:
    void GetManConclusion(Man* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"失败时，闷头喝酒，谁也不用劝。"<<endl;
    }

    void GetWomanConclusion(Woman* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"失败时，两眼泪汪汪，谁也劝不了。"<<endl;
    }

};

//恋爱
class Amativeness:public Action
{
public:
    void GetManConclusion(Man* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"恋爱时，不懂也要装懂。"<<endl;
    }

    void GetWomanConclusion(Woman* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"恋爱时，懂也要装不懂。"<<endl;
    }

};

//婚姻
class Marriage:public Action
{
public:
    void GetManConclusion(Man* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"结婚时，感慨道：恋爱游戏终结时，‘有妻徒刑’遥无期。"<<endl;
    }

    void GetWomanConclusion(Woman* concreteElement) override
    {
        cout<<concreteElement->GetGender()<<"结婚时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。"<<endl;
    }

};

//对象结构
class ObjectStructure
{
public:
    //添加
    void Attach(Person* person)
    {
        _elements.push_back(person);
    }

    //删除
    void Detach(Person* person)
    {
        if(!_elements.empty())
        {
            for(int i = 0;i != _elements.size();++i)
            {
                if(_elements[i] == person)
                {
                    _elements.erase(_elements.begin()+i);
                }
            }
        }else
        {
            cout<<"对象向量中没有元素请检查操作是否正确."<<endl;
        }
    }
    void Display(Action* visitor)
    {
        //遍历向量中存放的所有元素，调用accept
        for(auto i : _elements)
        {
            i->Accept(visitor);
        }
    }
private:
    vector<Person*> _elements;
};

int main()
{
    ObjectStructure object;
    object.Attach(new Man());
    object.Attach(new Woman());

    //成功反应
    Success* v1 = new Success();
    //显示反应
    object.Display(v1);
    //失败反应
    Failing* v2 = new Failing();
    //显示反应
    object.Display(v2);
    //恋爱反应
    Amativeness* v3 = new Amativeness();
    //显示反应
    object.Display(v3);
    //结婚反应
    Marriage* v4 = new Marriage();
    //显示反应
    object.Display(v4);

    return 0;
}

程序输出：

clh@clh:~/testcode/设计模式$ g++ visitor.cpp -std=c++11 -g
clh@clh:~/testcode/设计模式$ ./a.out 
男人成功时，背后多半有个伟大的女人。
女人成功时，背后多半有个不成功的男人。
男人失败时，闷头喝酒，谁也不用劝。
女人失败时，两眼泪汪汪，谁也劝不了。
男人恋爱时，不懂也要装懂。
女人恋爱时，懂也要装不懂。
男人结婚时，感慨道：恋爱游戏终结时，‘有妻徒刑’遥无期。
女人结婚时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。

以下内容摘抄自《设计模式》：
访问者模式适用性：
1.一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
2.需要对一个对象结构中的对象进行很多不同且不相关的操作，而你想避免让这些操作“污染”这些对象的类，visitor使得你可以将相关的操作集中起来定义在一个类中。
3.定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，者可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作比较好。

访问者模式的优点：
1.访问者模式易于增加新的操作 访问者使得增加以来于复杂对象结构的构建的操作变得更容易了。仅需增加一个新的访问者即可在一个对象结构上定义一个新的操作。相反，如果每个功能都分散在多个类智商的话，定义新的操作时必须修改每一个类。
2.访问者集中相关的操作而分离无关的操作 相关的行为不是分布在定义该对象结构的各个类上，而是集中在一个访问者中。无关行为却被分别放在它们各自的访问者子类中。这就简化了这些元素的类，也简化了在这些访问者中定义的算法。所有与它的算法相关的数据结构都可以被隐藏在访问者中。
3.访问限制少 可以访问不具有相同父类的对象。可以对一个visitor接口增加任何类型的对象，它们不必继承相同的父类。
4.积累状态 当访问者访问对象结构中的每一个元素时，它可能会积累状态。如果没有访问者，这一状态将作为额外的参数传递给进行遍历的操作，或者定义为全局变量。

访问者模式的缺点：
1.增加新的ConcreteElement类很困难 visitor模式使得难以增加新的Element的子类。每添加一个新的ConcreteElement都要visitor中添加一个新的抽象操作，并在每一个ConcretVisitor类中实现相应操作。
2.破坏封装 访问者方法嘉定ConcreteElement接口的功能足够强，足以让访问者进行它们的工作。结果时，该模式常常迫使你提供访问元素内部状态的公共操作，这可能会破坏它们的封装性。

转载请注明源地址：http://blog.csdn.net/clh01s