C++ 设计模式——访问者模式

于 2024-09-01 00:00:00 发布
阅读量1.6k 收藏 32
点赞数 17
分类专栏： # C++ 设计模式 文章标签： c++ 设计模式 访问者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141751399
版权

目录

C++ 设计模式——访问者模式

访问者模式（Visitor Pattern）是一种行为设计模式，其目的是将数据结构与数据操作分离，使得在不修改已有程序代码的情况下，可以添加新的操作。这种模式通过定义一个访问者类，来改变一个元素类的执行算法。访问者模式使得你能够在不改变元素类的前提下，定义作用于这些元素的新操作。

引人“访问者”模式的定义(实现意图)：提供一个作用于某对象结构中的各元素的操作表示，便可以在不改变各元素类的前提下定义（扩展）作用于这些元素的新操作。

1. 主要组成成分

  1. 抽象访问者（Visitor）: 提供一个访问元素的接口，声明了一系列访问具体元素的方法。
  2. 具体访问者（Concrete Visitor）: 实现抽象访问者中声明的操作，定义对每个元素的具体处理逻辑。
  3. 元素接口（Element）: 声明一个接受访问者的方法(accept)。
  4. 具体元素（Concrete Element）: 实现元素接口，通过接受访问者的方式允许访问者对其进行操作。
  5. 对象结构（Object Structure）: 能枚举它的元素，可以提供一个高层的接口以允许访问者访问其元素。

2. 逐步构建访问者模式

该示例代码将展示如何实现一个药品管理系统，使用访问者模式来处理不同的操作，如收费、取药和营养建议。

步骤1: 创建元素接口和具体元素

首先，定义一个Medicine类作为所有药品的基类，它包含一个名为accept的方法，该方法用于接受一个访问者对象。然后，创建具体的药品类，如M_asplcrp（阿司匹林肠溶片），M_fftdnhsp（氟伐他汀钠缓释片）和M_dlx（黛力新），它们都继承自Medicine并实现accept方法。

class Visitor; //类前向声明
//药品父类
class Medicine
{
public:
    virtual void Accept(Visitor* pvisitor) = 0;//这里的形参是访问者父类指针
public:
    virtual string getMdcName() = 0;  //药品名称
    virtual float getPrice() = 0;     //药品总价格，单位：元
};


//药品：阿司匹林肠溶片
class M_asplcrp : public Medicine
{
public:
    virtual string getMdcName()
    {
        return "阿司匹林肠溶片";
    }
    virtual float getPrice()
    {
        return 46.8f;    //为简化代码，直接给出药品总价而不单独强调药品数量了，比如该药品医生给开了两盒，一盒是23.4，那么这里直接返回两盒的价格
    }

public:
    virtual void Accept(Visitor* pvisitor);

};
//药品：氟伐他汀钠缓释片
class M_fftdnhsp : public Medicine
{
public:
    virtual string getMdcName()
    {
        return "氟伐他汀钠缓释片";
    }
    virtual float getPrice()
    {
        return 111.3f;    //三盒的价格
    }

public:
    virtual void Accept(Visitor* pvisitor);

};
//药品：黛力新
class M_dlx : public Medicine
{
public:
    virtual string getMdcName()
    {
        return "黛力新";
    }
    virtual float getPrice()
    {
        return 122.0f;    //两盒的价格
    }

public:
    virtual void Accept(Visitor* pvisitor);

};

//各个药品子类Accept方法的实现体代码
void M_asplcrp::Accept(Visitor* pvisitor)
{
    pvisitor->Visit_elm_asplcrp(this);
}
void M_fftdnhsp::Accept(Visitor* pvisitor)
{
    pvisitor->Visit_elm_fftdnhsp(this);
}
void M_dlx::Accept(Visitor* pvisitor)
{
    pvisitor->Visit_elm_dlx(this);
}
步骤2: 创建抽象访问者和具体访问者

然后，定义Visitor类作为抽象访问者，它包含对每种类型药品的访问方法。接着实现具体访问者类如Visitor_SFRY（收费人员），Visitor_QYRY（取药人员）和Visitor_YYS（营养师），分别定义它们如何处理每种药品。

//访问者父类
class Visitor
{
public:
    virtual ~Visitor() {} //做父类时析构函数应该为虚函数

    virtual void Visit_elm_asplcrp(M_asplcrp* pelem) = 0;//访问元素：阿司匹林肠溶片
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem) = 0;//访问元素：氟伐他汀钠缓释片
    virtual void Visit_elm_dlx(M_dlx* pelem) = 0; //访问元素：黛力新
};

//收费人员访问者子类
class Visitor_SFRY : public Visitor
{
public:
    virtual void Visit_elm_asplcrp(M_asplcrp* pelem)
    {
        float tmpprice = pelem->getPrice();
        cout << "收费人员累计药品“" << pelem->getMdcName() << "”的价格：" << tmpprice << endl;
        m_totalcost += tmpprice;
    }
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem)
    {
        float tmpprice = pelem->getPrice();
        cout << "收费人员累计药品“" << pelem->getMdcName() << "”的价格：" << tmpprice << endl;
        m_totalcost += tmpprice;
    }
    virtual void Visit_elm_dlx(M_dlx* pelem)
    {
        float tmpprice = pelem->getPrice();
        cout << "收费人员累计药品“" << pelem->getMdcName() << "”的价格：" << tmpprice << endl;
        m_totalcost += tmpprice;
    }

    //返回总费用
    float getTotalCost()
    {
        return m_totalcost;
    }
private:
    float m_totalcost = 0.0f;  //总费用
};

//取药人员访问者子类
class Visitor_QYRY : public Visitor
{
public:
    virtual void Visit_elm_asplcrp(M_asplcrp* pelem)
    {
        cout << "取药人员将药品“" << pelem->getMdcName() << "”拿给了我！" << endl;
    }
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem)
    {
        cout << "取药人员将药品“" << pelem->getMdcName() << "”拿给了我！" << endl;
    }
    virtual void Visit_elm_dlx(M_dlx* pelem)
    {
        cout << "取药人员将药品“" << pelem->getMdcName() << "”拿给了我！" << endl;
    }
};

//营养师访问者子类
class Visitor_YYS : public Visitor
{
public:
    virtual void Visit_elm_asplcrp(M_asplcrp* pelem)
    {
        cout << "营养师建议：“多吃粗粮少吃油，可以有效的预防血栓”！" << endl;
    }
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem)
    {
        cout << "营养师建议：“多吃蘑菇、洋葱、，猕猴桃，可以有效的降低血脂”！" << endl;
    }
    virtual void Visit_elm_dlx(M_dlx* pelem)
    {
        cout << "营养师建议：“多出去走走呼吸新鲜空气，多晒太阳，多去人多热闹的地方，保持乐观开朗的心情”！" << endl;
    }
};
步骤3:创建对象结构

接着，定义一个ObjectStructure类来管理药品集合，并允许将访问者应用于这些集合。这个类负责维护药品列表，并提供一个方法来执行访问者的操作。对象结构是连接元素和访问者的桥梁，使得不同的访问者可以对元素集合执行不同的操作。

//对象结构
class ObjectStructure
{
public:
    //增加药品到药品列表中
    void addMedicine(Medicine* p_mdc)
    {
        m_mdclist.push_back(p_mdc);
    }

    void procAction(Visitor* pvisitor)
    {
        for (auto iter = m_mdclist.begin(); iter != m_mdclist.end(); ++iter)
        {
            (*iter)->Accept(pvisitor);
        }
    }
private:
    list <Medicine*> m_mdclist;  //药品列表
};
步骤4: 客户端使用访问者模式

在客户端代码中，创建ObjectStructure对象，添加药品元素，并创建访问者对象。通过调用ObjectStructure的方法，将访问者应用到所有药品上，以实现具体的功能，如收费、取药或提供营养建议。

int main()
{
    Visitor_SFRY visitor_sf; //收费人员访问者子类，里面承载着向我（患者）收费的算法
    M_asplcrp mdc_asplcrp;
    M_fftdnhsp mdc_fftdnhsp;
    M_dlx mdc_dlx;

    //各个元素子类调用Accept接受访问者的访问，就可以实现访问者要实现的功能
    mdc_asplcrp.Accept(&visitor_sf); //累加“阿司匹林肠溶片”的价格
    mdc_fftdnhsp.Accept(&visitor_sf);//累加“氟伐他汀钠缓释片”的价格
    mdc_dlx.Accept(&visitor_sf);     //累加“黛力新”的价格

    cout << "所有药品的总为：" << visitor_sf.getTotalCost() << "，收费人员收取了我的费用！" << endl;

    //----
    Visitor_QYRY visitor_qy; //取药人员访问者子类，里面承载着向我发放药品的算法
    mdc_asplcrp.Accept(&visitor_qy); //我取得“阿司匹林肠溶片”
    mdc_fftdnhsp.Accept(&visitor_qy);// 我取得“氟伐他汀钠缓释片”
    mdc_dlx.Accept(&visitor_qy);     //我取得“黛力新”

    //-----
    Visitor_YYS visitor_yys;  //营养师访问者子类，里面承载着为我配置营养餐的算法
    mdc_asplcrp.Accept(&visitor_yys); //营养师针对治疗预防血栓药“阿司匹林肠溶片”给出的对应的营养餐建议
    mdc_fftdnhsp.Accept(&visitor_yys);//营养师针对降血脂药“氟伐他汀钠缓释片”给出的对应的营养餐建议
    mdc_dlx.Accept(&visitor_yys);     //营养师针对治疗神经紊乱药“黛力新”给出的对应的营养餐建议

    //---------
    ObjectStructure objstruc;
    objstruc.addMedicine(&mdc_asplcrp);
    objstruc.addMedicine(&mdc_fftdnhsp);
    objstruc.addMedicine(&mdc_dlx);
    objstruc.procAction(&visitor_yys); //将一个访问者对象（visitor_yys）应用到一批元素上，以实现对一批元素进行同一种（营养方面的）操作

    return 0;
}

3. 访问者模式 UML 图

访问者模式 UML 图

UML 图解析

访问者模式的 UML图中包含如下5种角色。

  • Visitor (抽象访问者)：为对象结构中的每个元素子类（例如M_asplcrp、M_fftdnhsp、M_dlx）声明一个访问操作（以Visit开头的方法）。通过这些操作的名称或参数类型，可以明确知道要访问的元素子类的类型。具体的访问者子类需要实现这些访问操作。此处指的是Visitor类。
  • ConcreteVisitor (具体访问者)：实现由抽象访问者声明的每个访问操作。每个操作用于访问对象结构中的一种特定类型的元素。这里指的是Visitor_SFRY、Visitor_QYRY和Visitor_YYS类。
  • Element (抽象元素)：定义了一个Accept方法，该方法通常接受一个指向抽象访问者类型的指针作为形参。这里指的是Medicine类。
  • ConcreteElement (具体元素)：实现Accept方法，在该方法中调用访问者子类中的访问操作（以Visit开头的方法），以便访问者能够对元素执行操作。这里指的是M_asplcrp、M_fftdnhsp和M_dlx类。
  • ObjectStructure (对象结构)：包含多个元素的集合，用于存储元素对象并提供遍历其内部元素的接口，通常用于对一组元素执行统一操作。

4. 访问者模式的优点

  1. 增加新操作容易：可以通过添加新的访问者类来增加新的操作，这符合开闭原则，允许系统易于扩展和维护。
  2. 聚合操作：访问者模式使得可以将相关的操作集中到一个访问者中，而不是分散在各个元素类中，这有助于组织和集中管理相关操作，减少系统的复杂性。
  3. 累积状态：访问者可以在访问元素时累积状态，而不需要将这些状态存储在元素之中，这有助于避免元素类变得臃肿，同时可以轻松地添加新的累积逻辑。

5. 访问者模式的缺点

  1. 破坏封装：访问者模式通常需要元素暴露一些原本应为私有的实现细节给访问者，这违反了面向对象的封装原则。
  2. 难以维护：如果经常添加新的元素类，每次添加都需要修改所有访问者类以添加新的访问操作，这可能导致代码难以维护。
  3. 复杂度增加：使用访问者模式会增加系统的复杂度，学习和理解系统的难度增加，特别是在具有大量元素和访问者的系统中。

6. 访问者模式适用场景

  1. 操作频繁变化：当系统的数据结构相对稳定，但操作经常变化时，使用访问者模式可以使这些操作易于修改和扩展。
  2. 需要对复合对象执行多种不相关的操作：当需要对一组对象结构执行很多不相关的操作时，而你又希望避免这些操作“污染”这些对象的类。
  3. 区分多种类型的元素：当一个对象结构包含多种类型的元素，并且你希望对这些元素执行一些依赖于其具体类型的操作时。

总结

在实际应用中，访问者模式特别适用于数据结构相对稳定，但操作经常变化的场景，例如在多种不同类型的对象上执行多种不相关的操作。通过将操作逻辑封装在访问者中，可以保持元素类的简洁并易于管理和扩展。总之，访问者模式是一种非常有用的设计工具，可以有效地帮助开发者管理和扩展复杂系统中的操作。

完整代码

#include <iostream>
#include <list>

using namespace std;

class Visitor; //类前向声明
//药品父类
class Medicine
{
public:
    virtual void Accept(Visitor* pvisitor) = 0;//这里的形参是访问者父类指针
public:
    virtual string getMdcName() = 0;  //药品名称
    virtual float getPrice() = 0;     //药品总价格，单位：元
};


//药品：阿司匹林肠溶片
class M_asplcrp : public Medicine
{
public:
    virtual string getMdcName()
    {
        return "阿司匹林肠溶片";
    }
    virtual float getPrice()
    {
        return 46.8f;    //为简化代码，直接给出药品总价而不单独强调药品数量了，比如该药品医生给开了两盒，一盒是23.4，那么这里直接返回两盒的价格
    }

public:
    virtual void Accept(Visitor* pvisitor);

};
//药品：氟伐他汀钠缓释片
class M_fftdnhsp : public Medicine
{
public:
    virtual string getMdcName()
    {
        return "氟伐他汀钠缓释片";
    }
    virtual float getPrice()
    {
        return 111.3f;    //三盒的价格
    }

public:
    virtual void Accept(Visitor* pvisitor);

};
//药品：黛力新
class M_dlx : public Medicine
{
public:
    virtual string getMdcName()
    {
        return "黛力新";
    }
    virtual float getPrice()
    {
        return 122.0f;    //两盒的价格
    }

public:
    virtual void Accept(Visitor* pvisitor);

};

//----------------
//访问者父类
class Visitor
{
public:
    virtual ~Visitor() {} //做父类时析构函数应该为虚函数

    virtual void Visit_elm_asplcrp(M_asplcrp* pelem) = 0;//访问元素：阿司匹林肠溶片
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem) = 0;//访问元素：氟伐他汀钠缓释片
    virtual void Visit_elm_dlx(M_dlx* pelem) = 0; //访问元素：黛力新
};

//收费人员访问者子类
class Visitor_SFRY : public Visitor
{
public:
    virtual void Visit_elm_asplcrp(M_asplcrp* pelem)
    {
        float tmpprice = pelem->getPrice();
        cout << "收费人员累计药品“" << pelem->getMdcName() << "”的价格：" << tmpprice << endl;
        m_totalcost += tmpprice;
    }
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem)
    {
        float tmpprice = pelem->getPrice();
        cout << "收费人员累计药品“" << pelem->getMdcName() << "”的价格：" << tmpprice << endl;
        m_totalcost += tmpprice;
    }
    virtual void Visit_elm_dlx(M_dlx* pelem)
    {
        float tmpprice = pelem->getPrice();
        cout << "收费人员累计药品“" << pelem->getMdcName() << "”的价格：" << tmpprice << endl;
        m_totalcost += tmpprice;
    }

    //返回总费用
    float getTotalCost()
    {
        return m_totalcost;
    }
private:
    float m_totalcost = 0.0f;  //总费用
};

//取药人员访问者子类
class Visitor_QYRY : public Visitor
{
public:
    virtual void Visit_elm_asplcrp(M_asplcrp* pelem)
    {
        cout << "取药人员将药品“" << pelem->getMdcName() << "”拿给了我！" << endl;
    }
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem)
    {
        cout << "取药人员将药品“" << pelem->getMdcName() << "”拿给了我！" << endl;
    }
    virtual void Visit_elm_dlx(M_dlx* pelem)
    {
        cout << "取药人员将药品“" << pelem->getMdcName() << "”拿给了我！" << endl;
    }
};

//营养师访问者子类
class Visitor_YYS : public Visitor
{
public:
    virtual void Visit_elm_asplcrp(M_asplcrp* pelem)
    {
        cout << "营养师建议：“多吃粗粮少吃油，可以有效的预防血栓”！" << endl;
    }
    virtual void Visit_elm_fftdnhsp(M_fftdnhsp* pelem)
    {
        cout << "营养师建议：“多吃蘑菇、洋葱、，猕猴桃，可以有效的降低血脂”！" << endl;
    }
    virtual void Visit_elm_dlx(M_dlx* pelem)
    {
        cout << "营养师建议：“多出去走走呼吸新鲜空气，多晒太阳，多去人多热闹的地方，保持乐观开朗的心情”！" << endl;
    }
};


//各个药品子类Accept方法的实现体代码
void M_asplcrp::Accept(Visitor* pvisitor)
{
    pvisitor->Visit_elm_asplcrp(this);
}
void M_fftdnhsp::Accept(Visitor* pvisitor)
{
    pvisitor->Visit_elm_fftdnhsp(this);
}
void M_dlx::Accept(Visitor* pvisitor)
{
    pvisitor->Visit_elm_dlx(this);
}

//-------------

//对象结构
class ObjectStructure
{
public:
    //增加药品到药品列表中
    void addMedicine(Medicine* p_mdc)
    {
        m_mdclist.push_back(p_mdc);
    }

    void procAction(Visitor* pvisitor)
    {
        for (auto iter = m_mdclist.begin(); iter != m_mdclist.end(); ++iter)
        {
            (*iter)->Accept(pvisitor);
        }
    }
private:
    list <Medicine*> m_mdclist;  //药品列表
};


int main()
{

    Visitor_SFRY visitor_sf; //收费人员访问者子类，里面承载着向我（患者）收费的算法
    M_asplcrp mdc_asplcrp;
    M_fftdnhsp mdc_fftdnhsp;
    M_dlx mdc_dlx;

    //各个元素子类调用Accept接受访问者的访问，就可以实现访问者要实现的功能
    mdc_asplcrp.Accept(&visitor_sf); //累加“阿司匹林肠溶片”的价格
    mdc_fftdnhsp.Accept(&visitor_sf);//累加“氟伐他汀钠缓释片”的价格
    mdc_dlx.Accept(&visitor_sf);     //累加“黛力新”的价格

    cout << "所有药品的总为：" << visitor_sf.getTotalCost() << "，收费人员收取了我的费用！" << endl;

    //----
    Visitor_QYRY visitor_qy; //取药人员访问者子类，里面承载着向我发放药品的算法
    mdc_asplcrp.Accept(&visitor_qy); //我取得“阿司匹林肠溶片”
    mdc_fftdnhsp.Accept(&visitor_qy);// 我取得“氟伐他汀钠缓释片”
    mdc_dlx.Accept(&visitor_qy);     //我取得“黛力新”

    //-----
    Visitor_YYS visitor_yys;  //营养师访问者子类，里面承载着为我配置营养餐的算法
    mdc_asplcrp.Accept(&visitor_yys); //营养师针对治疗预防血栓药“阿司匹林肠溶片”给出的对应的营养餐建议
    mdc_fftdnhsp.Accept(&visitor_yys);//营养师针对降血脂药“氟伐他汀钠缓释片”给出的对应的营养餐建议
    mdc_dlx.Accept(&visitor_yys);     //营养师针对治疗神经紊乱药“黛力新”给出的对应的营养餐建议

    //---------
    ObjectStructure objstruc;
    objstruc.addMedicine(&mdc_asplcrp);
    objstruc.addMedicine(&mdc_fftdnhsp);
    objstruc.addMedicine(&mdc_dlx);
    objstruc.procAction(&visitor_yys); //将一个访问者对象（visitor_yys）应用到一批元素上，以实现对一批元素进行同一种（营养方面的）操作

    return 0;
}
不是仙人的闲人
关注
专栏目录
C++ 访问者模式
青春不老，奋斗不止！
02-24 7202
访问者模式（Visitor Pattern）表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
《C++20设计模式》访问者模式
最新发布
Ten_years_star的博客
07-11 1298
《C++20设计模式》访问者模式
c++ 访问者模式
TimothyFly的专栏
08-16 1708
/** VISITOR模式：将操作独立于类之外，类根据自己需要的操作而接受相应的访问者。 这样做的好处是如果需要实现一个新操作，类的结构不用变，特别是整个类层次的操作，如果要变，代价是比较大的。 使用Visitor模式就可以保证增加操作非常简单方便，并且符合OCP了。 Visitor模式有一个吓人的概念：双分派，其实所谓的双分派也只不过是指：要定义一个操作，需要两个对象
C++中的访问者模式
GOLOJO的博客
06-12 389
访问者模式使得我们可以在不修改元素类的情况下扩展新的操作。
C++访问者模式
weixin_41564287的博客
07-24 185
介绍 意图：主要将数据结构与数据操作分离。 主要解决：稳定的数据结构和易变的操作耦合问题。 何时使用：需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。 如何解决：在被访问的类里面加一个对外提供接待访问者的接口。 关键代码：在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。 应用实例：您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。 优点： 1、符合单一
C++设计模式——访问者模式（visitor pattern）
净无邪博客
11-13 1474
一、原理讲解 1.1意图 表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 1.2应用场景 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作； 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免这些操作“污染”这些对象的类； 定义对象结构的类很少改变，但经常需要在此结构定义新的操作； 1.3结构图（UML图） 1.4代码实现步骤 a1 定义接口命令类Command，定义一个执行接口函数e
C++设计模式之访问者模式
01-21
这是23+1（简单工厂模式）之中的最后一个了——访问者模式。访问者模式也是一个比较麻烦的设计模式。我也没有实战经验，对于访问者模式的理解完全来自GOF的《设计模式:可复用面向对象软件的基础》，而这篇文章就是...
C++设计模式--基于Qt4开源跨平台开发框架
01-06
行为型模式如观察者模式（Observer）、策略模式（Strategy）和访问者模式（Visitor），关注对象之间的交互和责任分配。 在C++中，设计模式的应用通常涉及到面向对象编程的特性，如继承、封装和多态。Qt4框架则为...
C++设计模式——组合模式（composite pattern）
净无邪博客
10-21 922
# 一、原理讲解 ## 1.1意图 将对象组合成树形结构以表示“部分 — 整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 ## 1.2应用场景 - 你想表示对象的部分 — 整体层次结构； - 你
C++ 设计模式 —— 组合模式
莫寒技术人生
10-13 1339
组合模式的定义组合模式的作用组合模式是一种行为型设计模式，它将对象组合成树形结构以表示部分 - 整体的层次结构。这种模式使得用户对单个对象和组合对象的使用具有一致性。组合模式主要应用于需要表示复杂对象结构或者需要将对象组合成树形结构的场景。组合模式的定义和作用：定义：组合模式通过一种巧妙的设计方案，可以一致性地处理整个树形结构或者树形结构的一部分，也可以一致性地处理树形结构中的叶子节点（不包含子节点的节点）和容器节点。
c++访问者模式
waxtear的博客
02-11 325
访问者模式是为了给固定接口增加新的接口。访问者模式有一个巨大的缺陷就是需要增加接口的那个类不能再派生新的类。`c++`现在有了仿函数（重载括号）来替换这种模式，更加灵活。
【C++】访问者模式
明朗晨光的专栏
01-13 416
根据对象类型执行不同的功能，就是对象类型到功能之间的映射需求： #include <iostream> using namespace std; class Base { public : virtual void say() = 0; virtual ~Base() {} }; class A : public Base { public : void say() override { cout << "Class A" <<
访问者模式C++实现
mz5111089的专栏
02-11 247
解释器模式，可理解的场景有，五线谱解读为哆啦咪发唆西多，翻译，名词解释等。可交叉解析，也可用一种解析器解析。待解析内容：  #pragma once#include &lt;iostream&gt;using namespace std;class InterContext{public:    InterContext(void);    ~InterContext(void);    Inte...
访问者模式【行为模式C++】
weixin_39775340的博客
04-13 1756
访问者模式是一种行为设计模式， 它能将算法与其所作用的对象隔离开来。访问者模式主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不污染数据本身，访问者会将多种算法独立归档，并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并确保算法的自由扩展。访问者模式在实际开发中使用的非常少，因为它比较难以实现并且应用该模式肯能会导致代码的可读性变差，可维护性变差，在没有特别必要的情况下，不建议使用访问者模式。
访问者模式（C++实现）
qq_23903863的博客
08-15 307
（本博客旨在个人总结回顾） 1、详情： 访问者模式：表示一个作用于某对象结构中各元素的操作。它可以使你在不改变这些元素的类的前提下，定义作用于这些元素的新操作。 说明： 优点： ①符合单一职责原则。 ②优秀的扩展性、灵活性。 缺点： ①具体元素对访问者公布细节，违反了迪米特原则。 ②具体元素变更比较困难。 ③违反了依赖倒置原则，依赖了具体类，没有依赖抽象。 使用场景：...
C++设计模式解析：GoF23种模式详解
"C++设计模式.pdf 是一本详细介绍GoF23种设计模式的书籍，包含C++实现的源码，旨在帮助读者理解和掌握面向对象分析和设计的关键——设计模式。作者通过自己的学习经验和实际项目应用，解析了每种模式，并提供了实践...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值