23 访问者模式

原文转载：https://blog.csdn.net/sinat_21107433/article/details/103000119

欧耶！这周Jungle的作业终于做完了！作业是什么呢？就是完成一个习题册。Jungle做完之后，得让家长检查习题册并签字；第二天交到学校，组长得初步检查作业是否做完、家长是否签字，然后老师会评阅作业是否正确，并给出评分。

就是这么一个习题册，这是经了多少人的手啊！

            Jungle——完成习题册上的题；

            Jungle家长——检查儿子的作业，并在习题册上签字；

            组长——初步检查Jungle的习题册是否完成；

            老师——评阅习题册，给出评分。

同样一个对象（习题册），不同的人都去访问它，并且访问的方式不同，Jungle是为了完成作业，Jungle爸爸是为了签字，组长是为了检查Jungle是否完成，而老师是为了评分。 每一个人都扮演了访问者的角色。

什么？访问者？

1.访问者模式简介

类似于上述的习题册，软件设计中也需要这样的类似于习题册的对象结构，不同的对象对应不同的处理。设计模式中，访问者模式就是为了以不同的方式来操作复杂的对象结构。

访问者模式是一种较为复杂的行为型设计模式，具有访问者和被访问元素两个主要的角色。被访问的元素常常有不同的类型，不同的访问者可以对它们提供不同的访问方式。被访问元素通常不是单独存在，而是以集合的形式存在于一个对象结构中，访问者可以遍历该对象结构，以逐个访问其中的每一个元素。

访问者模式：

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

2.访问者模式结构

访问者模式的结构相对较复杂，角色有如下几个：

• Visitor（抽象访问者）：抽象类，声明了访问对象结构中不同具体元素的方法，由方法名称可知该方法将访问对象结构中的某个具体元素；
• ConcreteVisitor（具体访问者）：访问某个具体元素的访问者，实现具体的访问方法；
• Element（抽象元素）：抽象类，一般声明一个accept()的方法，用于接受访问者的访问，accept()方法常常以一个抽象访问者的指针作为参数；
• ConcreteElement（具体元素）：针对具体被访问的元素，实现accept()方法；
• ObjectStructure（对象结构）：元素的集合，提供了遍历对象结构中所有元素的方法。对象结构存储了不同类型的元素对象，以供不同的访问者访问。

访问者模式的UML结构图如下：

 从上图和前述可以看出，访问者模式中有两个层次结构：

• 访问者的层次结构：抽象访问者和具体访问者，不同的具体访问者有不同的访问方式（visit()方式）；
• 被访问元素的层次结构：抽象元素和具体元素，不同的具体元素有不同的被访问方式（accept()方式）

正式由于有这两个层次结构，在增加新的访问者时，不必修改已有的代码，通过继承抽象访问者即可实现扩展，符合开闭原则，系统扩展性较好。但是在增加新的元素时，既要修改抽象访问者类（增加访问新增元素方法的声明），又要修改具体访问者（增加新的具体访问者类），不符合开闭原则。

访问者模式的示例代码如下：

1. #ifndef __DEMO_H__

2. #define __DEMO_H__

3.  

4. // 抽象访问者 Visitor

5. class Visitor

6. {

7. public:

8. virtual void visit(ConcreteElementA*) = 0;

9. virtual void visit(ConcreteElementB*) = 0;

10. };

11.  

12. // 具体访问者 ConcreteVisitor

13. class ConcreteVisitor :public Visitor

14. {

15. public:

16. // 实现一种针对特定元素的访问操作

17. void visit(ConcreteElementA*){

18. // 元素A的访问操作代码

19. }

20. void visit(ConcreteElementB*){

21. // 元素B的访问操作代码

22. }

23. };

24.  

25. // 抽象元素

26. class Element

27. {

28. public:

29. // 声明抽象方法，以一个抽象访问者的指针作为函数参数

30. virtual void accept(Visitor*) = 0;

31. };

32.  

33. // 具体元素

34. class ConcreteElement :public Element

35. {

36. public:

37. void accept(Visitor* visitor){

38. visitor->visit(this);

39. }

40. };

41.  

42. // 对象结构

43. class ObjectStructure

44. {

45. public:

46. // 提供接口接受访问者访问

47. void accept(Visitor* visitor){

48. // 遍历访问对象结构中的元素

49. for (){

50. elementList[i]->accept(visitor);

51. }

52. }

53. void addElement(){}

54. void removeElement(){}

55. private:

56. lsit<Element*>elementList;

57. };

58.  

59. #endif

3.访问者模式代码实例

Jungle作为一名顾客，去超市购物，加入购物车的商品包括两种苹果和两本书，结账时收银员需要计算各个商品的的价格。本例Jungle采用访问者模式来模拟该过程。

本例中，客户Jungle和收银员都会去访问商品，但关心的地方不同：Jungle关心的是苹果和书的单价、品牌等，收银员关注的是商品的价格。因此，客户Customer和收银员Cashier是具体访问者，而苹果Apple和书Book是具体被访问元素；而购物车则是对象结构。本例的UML图如下：

3.1.元素类

3.1.1.抽象元素

1. // 抽象元素

2. class Element

3. {

4. public:

5. Element(){};

6. virtual void accept(Visitor*) = 0;

7. void setPrice(int iPrice){

8. this->price = iPrice;

9. }

10. int getPrice(){

11. return this->price;

12. }

13. void setNum(int iNum){

14. this->num = iNum;

15. }

16. int getNum(){

17. return num;

18. }

19. void setName(string iName){

20. this->name = iName;

21. }

22. string getName(){

23. return this->name;

24. }

25. private:

26. int price;

27. int num;

28. string name;

29. };

3.1.2.具体元素Apple

1. // 具体元素：Apple

2. class Apple :public Element

3. {

4. public:

5. Apple();

6. Apple(string name, int price);

7. void accept(Visitor*);

8. };

实现：

1. Apple::Apple(){

2. setPrice(0);

3. setNum(0);

4. setName("");

5. }

6. Apple::Apple(string name, int price){

7. setPrice(price);

8. setNum(0);

9. setName(name);

10. }

11.  

12. void Apple::accept(Visitor* visitor){

13. visitor->visit(this);

14. }

 3.1.3.具体元素Book

1. // 具体元素：Book

2. class Book :public Element

3. {

4. public:

5. Book();

6. Book(string name, int price);

7. void accept(Visitor*);

8. };

实现：

1. Book::Book(){

2. setPrice(0);

3. setNum(0);

4. setName("");

5. }

6.  

7. Book::Book(string iName, int iPrice){

8. setPrice(iPrice);

9. setNum(0);

10. setName(iName);

11. }

12.  

13. void Book::accept(Visitor* visitor){

14. visitor->visit(this);

15. }

 3.2.访问者

3.2.1.抽象访问者

1. // 抽象访问者

2. class Visitor

3. {

4. public:

5. Visitor(){};

6. // 声明一组访问方法

7. virtual void visit(Apple*) = 0;

8. virtual void visit(Book*) = 0;

9. };

3.2.2.具体访问者Customer

1. // 具体访问者：顾客

2. class Customer :public Visitor

3. {

4. public:

5. Customer();

6. Customer(string iName);

7. void setNum(Apple*, int);

8. void setNum(Book*, int);

9. void visit(Apple* apple);

10. void visit(Book* book);

11. private:

12. string name;

13. };

实现：

1. Customer::Customer(){

2. this->name = "";

3. }

4.  

5. Customer::Customer(string iName){

6. this->name = iName;

7. }

8.  

9. void Customer::setNum(Apple* apple, int iNum){

10. apple->setNum(iNum);

11. }

12. void Customer::setNum(Book* book, int iNum){

13. book->setNum(iNum);

14. }

15.  

16. void Customer::visit(Apple* apple){

17. int price = apple->getPrice();

18. printf(" %s \t单价: \t%d 元/kg\n", apple->getName().c_str(), apple->getPrice());

19. }

20.  

21. void Customer::visit(Book* book){

22. int price = book->getPrice();

23. string name = book->getName();

24. printf(" 《%s》\t单价: \t%d 元/本\n", book->getName().c_str(), book->getPrice());

25. }

3.2.3.具体访问者Cashier

1. class Cashier :public Visitor

2. {

3. public:

4. Cashier();

5. void visit(Apple* apple);

6. void visit(Book* book);

7. };

实现：

1. Cashier::Cashier(){

2.  

3. }

4.  

5. void Cashier::visit(Apple* apple){

6. string name = apple->getName();

7. int price = apple->getPrice();

8. int num = apple->getNum();

9. int total = price*num;

10. printf(" %s 总价： %d 元\n", name.c_str(), total);

11. }

12.  

13. void Cashier::visit(Book* book){

14. int price = book->getPrice();

15. string name = book->getName();

16. int num = book->getNum();

17. int total = price*num;

18. printf(" 《%s》 总价： %d 元\n", name.c_str(), total);

19. }

3.3.购物车ShoppingCart

1. class ShoppingCart

2. {

3. public:

4. ShoppingCart(){}

5. void addElement(Element* element){

6. printf(" 商品名：%s, \t数量：%d, \t加入购物车成功！\n", element->getName().c_str(), element->getNum());

7. elementList.push_back(element);

8. }

9. void accept(Visitor* visitor){

10. for (int i = 0; i < elementList.size(); i++){

11. elementList[i]->accept(visitor);

12. }

13. }

14. private:

15. vector<Element*>elementList;

16. };

3.4.客户端代码示例及结果

1. #include "Element.h"

2. #include "Visitor.h"

3. #include "ShoppingCart.h"

4. #include <Windows.h>

5.  

6. int main()

7. {

8. Apple *apple1 = new Apple("红富士苹果", 7);

9. Apple *apple2 = new Apple("花牛苹果", 5);

10. Book *book1 = new Book("红楼梦", 129);

11. Book *book2 = new Book("终结者", 49);

12.  

13. Cashier* cashier = new Cashier();

14. Customer* jungle = new Customer("Jungle");

15. jungle->setNum(apple1, 2);

16. jungle->setNum(apple2, 4);

17. jungle->setNum(book1, 1);

18. jungle->setNum(book2, 3);

19.  

20. ShoppingCart* shoppingCart = new ShoppingCart();

21. shoppingCart->addElement(apple1);

22. shoppingCart->addElement(apple2);

23. shoppingCart->addElement(book1);

24. shoppingCart->addElement(book2);

25.  

26. printf("\n\n");

27. shoppingCart->accept(jungle);

28.  

29. printf("\n\n");

30. shoppingCart->accept(cashier);

31.  

32. printf("\n\n");

33. system("pause");

34. return 0;

35. }

上述代码运行结果如下：

 上述代码资源见https://github.com/FengJungle/DesignPattern

4.总结

访问者模式的结构相对较复杂，在实际应用中使用频率较低。如果系统中存在一个复杂的对象结构，且不同的访问者对其具有不同的操作，那么可以考虑使用访问者模式。访问者模式的特点总结如下：

优点：

• 增加新的访问者很方便，即增加一个新的具体访问者类，定义新的访问方式，无需修改原有代码，符合开闭原则；
• 被访问元素集中在一个对象结构中，类的职责更清晰，利于对象结构中元素对象的复用；

缺点：

• 增加新的元素类很困难，增加新的元素时，在抽象访问者类中需要增加一个对新增的元素方法的声明，即要修改抽象访问者代码；此外还要增加新的具体访问者以实现对新增元素的访问，不符合开闭原则；
• 破坏了对象的封装性，访问者模式要求访问者对象访问并调用每一个元素对象的操作，那么元素对象必须暴露自己的内部操作和状态，否则访问者无法访问。