实战设计模式之访问者模式

概述

        访问者模式允许我们在不改变类的前提下，向已有类添加新的功能。简单来说，就是将算法与对象的数据结构进行分离的一种方法。在实际应用中，当我们需要对一组对象执行一些操纵，而这些操纵又需要随着需求的变化而不断变化时，访问者模式就显得尤为紧张了。
        电子商务平台的库存管理体系是现实生存中运用访问者模式的一个范例例子。电子商务平台会贩卖不同种类的商品，比如：书籍、电子产品和服装等。我们需要定期对库存进行不同的统计分析，包括：计算总代价、统计数目等。随着业务的发展，大概会有新的商品范例加入，也大概会有新的统计需求出现。访问者模式允许我们将特定的商品处置惩罚逻辑与商品类本身分离，使得添加新的商品范例或处置惩罚逻辑变得更为简单和机动。

基本原理

        访问者模式的核心头脑是：将算法与对象结构分离。具体来说，访问者模式通过定义一个操纵（通常称为“访问”），这个操纵可以在不修改该元素的类的前提下，为每一个具体元素类声明一个该操纵。在访问者模式中，我们有两个主要的角色：一个是接受访问的对象聚集（即元素），另一个是对这些对象执行操纵的访问者。元素知道如何接受访问者，并且会调用访问者的相应方法来完成操纵。
        访问者模式主要由以下五个核心组件构成。
        1、访问者。为每一个具体元素声明一个访问操纵，表示访问者访问一个元素所要完成的工作。通常环境下，访问者会包罗多个Visit方法，每个方法对应一种具体的元素范例。
        2、具体访问者。实现了访问者接口中的每种Visit方法，以完成具体的业务逻辑。
        3、元素。定义了一个接受访问者的接口Accept，其主要作用是让访问者访问自身。同时，Element也是一个抽象类，代表了一组可以被访问的对象。
        4、具体元素。通常是那些需要被访问的对象，实现了Element接口，并提供自身的具体实现。
        5、对象结构。管理元素对象的聚集，提供了遍历元素的方法。
        基于上面的核心组件，访问者模式的实现主要有以下五个步骤。
        1、定义元素接口。创建一个抽象类或接口，至少声明了一个Accept方法。该方法用于吸收一个访问者对象，并调用访问者的相应Visit方法来执行对当前元素的操纵。
        2、创建具体元素类。对于每一个需要被访问的具体元素，创建一个继承自元素接口的类。在每个具体元素类中，实现Accept方法，使其调用传入的访问者对象的对应Visit方法，并通报自身作为参数。
        3、定义访问者接口。创建一个接口，为每种具体访问者范例定义一个Visit方法。这意味着，每当添加一个新的具体访问者范例时，都需要向访问者接口中添加一个新的Visit方法声明。
        4、实现具体访问者类。根据具体的业务逻辑需求，创建实现访问者接口的具体访问者类。在这些类中，实现全部声明的Visit方法，每个方法都包罗了针对特定访问者范例的处置惩罚逻辑。
        5、创建对象结构。创建一个管理元素聚集的对象结构，可以是一个简单的容器，也可以是更复杂的数据结构。此对象结构应提供遍历其内部元素的方法，并可以或许接受一个访问者对象，依次对其内部的每个元素调用Accept方法。

实战代码

        在下面的实战代码中，我们利用访问者模式模拟了电子商务平台库存管理体系的实现。
        起首，我们定义了一个抽象基类CProduct，它包罗商品的基本信息（名称、价格、库存量），并声明了一个纯虚函数Accept用于吸收访问者对象。
        接着，我们定义了两个具体的商品类CBook和CElectronics。它们继承自CProduct，并实现了Accept方法。该方法调用传入的访问者的相应Visit方法，以执行针对具体商品范例的特定操纵。
        然后，我们定义了一个抽象访问者类CVisitor。其中声明了针对每种商品范例的Visit方法，并通过具体访问者类CStockValueCalculator实现了这些方法，用来计算库存总代价。此外，还有一个管理商品聚集的对象结构类CInventory。它负责存储商品实例，并提供了一个PerformCalculations方法遍历全部商品，对每个商品调用其Accept方法，传入具体的访问者对象以执行相应的业务逻辑。
        末了，在main函数中，我们创建了一个CInventory实例。在添加了几种不同范例的商品后，我们利用CStockValueCalculator访问者来计算库存总代价，并终极输出了结果。

1. #include <iostream>
2. #include <vector>
3. #include <string>
5. using namespace std;
7. class CVisitor;
9. // 元素接口
10. class CProduct
11. {
12. public:
13.     CProduct(const string& name, double price, int stock) :
14.         m_strName(name), m_dbPrice(price), m_nStock(stock) {}
15.     virtual ~CProduct() {}
17.     virtual void Accept(CVisitor& visitor) = 0;
19.     string GetName() const { return m_strName; }
20.     double GetPrice() const { return m_dbPrice; }
21.     int GetStock() const { return m_nStock; }
23. protected:
24.     string m_strName;
25.     double m_dbPrice;
26.     int m_nStock;
27. };
29. // 具体元素：书籍
30. class CBook : public CProduct
31. {
32. public:
33.     CBook(const string& name, double price, int stock) :
34.         CProduct(name, price, stock) {}
36.     void Accept(CVisitor& visitor) override;
37. };
39. // 具体元素：电子产品
40. class CElectronics : public CProduct
41. {
42. public:
43.     CElectronics(const string& name, double price, int stock) :
44.         CProduct(name, price, stock) {}
45.    
46.     void Accept(CVisitor& visitor) override;
47. };
49. // 访问者接口
50. class CVisitor
51. {
52. public:
53.     virtual ~CVisitor() {}
54.     virtual void Visit(CBook& book) = 0;
55.     virtual void Visit(CElectronics& electronics) = 0;
56. };
58. // 具体访问者：计算库存总价值
59. class CStockValueCalculator : public CVisitor
60. {
61. public:
62.     void Visit(CBook& book) override
63.     {
64.         m_dbTotalValue += book.GetPrice() * book.GetStock();
65.     }
67.     void Visit(CElectronics& electronics) override
68.     {
69.         m_dbTotalValue += electronics.GetPrice() * electronics.GetStock();
70.     }
72.     double GetTotalValue() const { return m_dbTotalValue; }
74. private:
75.     double m_dbTotalValue = 0.0;
76. };
78. void CBook::Accept(CVisitor& visitor)
79. {
80.     visitor.Visit(*this);
81. }
83. void CElectronics::Accept(CVisitor& visitor)
84. {
85.     visitor.Visit(*this);
86. }
88. // 对象结构，用于管理商品集合
89. class CInventory
90. {
91. public:
92.     ~CInventory()
93.     {
94.         for (CProduct* product : m_vctProduct)
95.         {
96.             delete product;
97.         }
98.     }
100.     void AddProduct(CProduct* product)
101.     {
102.         m_vctProduct.push_back(product);
103.     }
105.     void PerformCalculations(CVisitor& visitor)
106.     {
107.         for (CProduct* product : m_vctProduct)
108.         {
109.             product->Accept(visitor);
110.         }
111.     }
113. private:
114.     vector<CProduct*> m_vctProduct;
115. };
117. int main()
118. {
119.     CInventory inventory;
120.     inventory.AddProduct(new CBook("Effective C++", 50.0, 10));
121.     inventory.AddProduct(new CElectronics("Phone", 1999.99, 20));
123.     CStockValueCalculator calculator;
124.     inventory.PerformCalculations(calculator);
125.     cout << "Total stock value: " << calculator.GetTotalValue() << endl;
126.     return 0;
127. }

复制代码

总结

        通过将算法从对象结构中分离出来，访问者模式使得每个角色（元素和访问者）都只负责本身的部门。别的，访问者模式使得添加新的操纵变得容易，而不需要修改现有的类。只需创建一个新的访问者类来实现所需的操纵即可，无需改动已有的元素类。
        但引入访问者模式会增加体系的设计复杂度，特别是当对象结构中有大量不同范例元素时，需要为每种范例定义相应的Visit方法，增加了代码量和理解难度。访问者需要知道全部被访问元素的具体范例和内部表示，这大概会导致访问者与元素之间产生紧密耦合，从而破坏了封装性。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。