024 --- 第28章 访问者模式

简述：

　　访问者模式：表示一个作用于某对象结构中各个元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

　　访问者模式包括：抽象访问者类、具体访问者类、对象枚举结构类、抽象元素类、具体元素类。

　　　　抽象访问者类：为该对象结构中的每个具体元素类对象声明一个Visit操作。

　　　　具体访问者类：实现每个由抽象访问者类声明的操作，每个操作实现算法的一部分，而该算法片段乃是对应于结构中对象的类。

　　　　对象枚举结构类：能枚举它的元素，可以提供一个高层的接口以允许访问者访问它的元素。

　　　　抽象元素类：定义一个Accept操作，它以一个访问者为参数。

　　　　具体元素类：实现Accept操作。

 

应用场景：对象枚举类包含元素类列表，可以为元素类对象添加访问者类对象进行访问。使用在数据结构相对稳定的系统中，把算法和数据结构分离

 

注：开发环境调整为VS2017，操作系统win11

访问者模式：

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

class CVisitor;
// 抽象元素类
class CElement
{
public:
    virtual void Accept(CVisitor* pVisitor) = 0;
};

// 抽象访问者类
class CVisitor
{
public:
    virtual void VisitConcreteElementA(CElement* pConcreteElementA) = 0;
    virtual void VisitConcreteElementB(CElement* pConcreteElementB) = 0;
};

// 具体元素类
class CConcreteElementA : public CElement
{
    virtual void Accept(CVisitor* pVisitor) { pVisitor->VisitConcreteElementA(this); }

    void OperationA() {}
};

// 具体元素类
class CConcreteElementB : public CElement
{
    virtual void Accept(CVisitor* pVisitor) { pVisitor->VisitConcreteElementB(this); }

    void OperationB() {}
};

// 具体访问者类
class CConcreteVisitor1 : public CVisitor
{
public:
    virtual void VisitConcreteElementA(CElement* pConcreteElementA)
    {
        cout << "CConcreteElementA 被 CConcreteVisitor1 访问" << endl;
    }
    virtual void VisitConcreteElementB(CElement* pConcreteElementB)
    {
        cout << "CConcreteElementB 被 CConcreteVisitor1 访问" << endl;
    }
};

// 具体访问者类
class CConcreteVisitor2 : public CVisitor
{
public:
    virtual void VisitConcreteElementA(CElement* pConcreteElementA)
    {
        cout << "CConcreteElementA 被 CConcreteVisitor2 访问" << endl;
    }
    virtual void VisitConcreteElementB(CElement* pConcreteElementB)
    {
        cout << "CConcreteElementB 被 CConcreteVisitor2 访问" << endl;
    }
};

// 对象枚举结构类
class CObjectStructure
{
private:
    list<CElement*> m_listElements;

public:
    void Attach(CElement* pElement) { m_listElements.push_back(pElement); }

    void Detach(CElement* pElement) { m_listElements.remove(pElement); }

    void Accpet(CVisitor* pVisitor)
    {
        for (auto element : m_listElements)
            element->Accept(pVisitor);
    }
};

int main()
{
    CObjectStructure obj;

    CConcreteElementA a;
    obj.Attach(&a);

    CConcreteElementB b;
    obj.Attach(&b);

    CConcreteVisitor1 v1;
    CConcreteVisitor2 v2;

    obj.Accpet(&v1);
    obj.Accpet(&v2);

    system("pause");
    return 0;
}

 

输出结果：

 

 

 

例：男人女人成功失败

代码如下：

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

class CAction;
// 人类（抽象元素类）
class CPerson
{
public:
    // 接受
    virtual void Accept(CAction* pAction) = 0;
};

// 状态抽象类（抽象访问者类）
class CAction
{
public:
    virtual void GetManConclusion(CPerson* pMan) = 0;
    virtual void GetWomanConclusion(CPerson* pWoman) = 0;
};

// 男人类（具体元素类）
class CMan : public CPerson
{
public:
    virtual void Accept(CAction* pAction) { pAction->GetManConclusion(this); }
};

// 女人类（具体元素类）
class CWoman : public CPerson
{
public:
    virtual void Accept(CAction* pAction) { pAction->GetWomanConclusion(this); }
};

// 成功类（具体访问者类）
class CSuccess : public CAction
{
public:
    virtual void GetManConclusion(CPerson* pMan)
    {
        cout << "男人成功时，背后多半有一个伟大的女人。" << endl;
    }
    virtual void GetWomanConclusion(CPerson* pWoman)
    {
        cout << "女人成功时，背后大多有一个不成功的男人。" << endl;
    }
};

// 失败类（具体访问者类）
class CFailing : public CAction
{
public:
    virtual void GetManConclusion(CPerson* pMan)
    {
        cout << "男人失败时，闷头喝酒，谁也不用劝。" << endl;
    }
    virtual void GetWomanConclusion(CPerson* pWoman)
    {
        cout << "女人失败时，眼泪汪汪，谁也劝不了。" << endl;
    }
};

// 恋爱类（具体访问者类）
class CAmativeness : public CAction
{
public:
    virtual void GetManConclusion(CPerson* pMan)
    {
        cout << "男人恋爱时，凡事不懂也要装懂。" << endl;
    }
    virtual void GetWomanConclusion(CPerson* pWoman)
    {
        cout << "女人恋爱时，遇事懂也装作不懂。" << endl;
    }
};

// 结婚类（具体访问者类）
class CMarriage : public CAction
{
public:
    virtual void GetManConclusion(CPerson* pMan)
    {
        cout << "男人结婚时，感慨到：恋爱游戏终结时，‘有妻徒刑’遥无期。" << endl;
    }
    virtual void GetWomanConclusion(CPerson* pWoman)
    {
        cout << "女人结婚时，欣慰到：爱情长跑路漫漫，婚姻保险保平安。" << endl;
    }
};

// 对象结构类
class CObjectStructure
{
private:
    list<CPerson*> m_listPerson;

public:
    // 增加
    void Attach(CPerson* pPerson) { m_listPerson.push_back(pPerson); }

    // 移除
    void Detach(CPerson* pPerson) { m_listPerson.remove(pPerson); }

    // 查看显示
    void Display(CAction* pAction)
    {
        for (auto person : m_listPerson)
            person->Accept(pAction);
    }
};

int main()
{
    CObjectStructure obj;
    CMan man;
    obj.Attach(&man);
    CWoman woman;
    obj.Attach(&woman);

    // 成功时的反应
    CSuccess success;
    obj.Display(&success);

    // 失败时的反应
    CFailing failing;
    obj.Display(&failing);

    // 恋爱时的反应
    CAmativeness amtiveness;
    obj.Display(&amtiveness);

    // 结婚时的反应
    CMarriage marriage;
    obj.Display(&marriage);

    system("pause");
    return 0;
}

 

输出结果：