C ++ design mode implementation-Visitor (Visitor) Mode

1. Visitor Mode

Definition: an operation that acts on each element in an object structure. It allows you to define new operations that act on these elements without changing the classes of each element.

The structure is as follows:

Ii. Example

Assume that a scientific experiment is used to compare the growth of the two seeds in different environments.

Two seeds: Seed_A and Seed_ B ).

The growth environment is in rainy environment (Rain_Status), Sun_Status, and so on.

The structure is as follows:

The Code is as follows:

[Cpp]View plaincopy

1. // Status
2. Class Status
3. {
4. Public:
5. Virtual ~ Status (){}
7. Virtual void VisitSeed_A (Seed * elm ){}
9. Virtual void VisitSeed_ B (Seed * elm ){}
11. Protected:
12. Status (){}
13. };
15. // Rain status
16. Class Rain_Status: public Status
17. {
18. Public:
19. Rain_Status (){}
21. Virtual ~ Rain_Status (){}
23. // The growth of A seed in the rain
24. Virtual void VisitSeed_A (Seed * elm)
25. {
26. Cout <"Rain will visit Seed A..." < }
28. // The Growth of B seeds in the rain Condition
29. Virtual void VisitSeed_ B (Seed * elm)
30. {
31. Cout <"Rain will visit Seed B..." < }
32. };
34. // Sunshine status
35. Class Sun_Status: public Status
36. {
37. Public:
38. Sun_Status (){}
40. Virtual ~ Sun_Status (){}
42. // The growth of A seed in the sunlight
43. Virtual void VisitSeed_A (Seed * elm)
44. {
45. Cout <"Sun will visit Seed A..." < }
47. // The Growth of B seeds in the sunlight
48. Virtual void VisitSeed_ B (Seed * elm)
49. {
50. Cout <"Sun will visit Seed B..." < }
51. };
55. // Seed
56. Class Seed
57. {
58. Public:
59. Virtual ~ Seed (){}
60. Virtual void Accept (Status * vis) = 0;
62. Protected:
63. Seed (){}
64. };
66. // Seed A, which is assumed to be A normal seed
67. Class Seed_A: public Seed
68. {
69. Public:
70. Seed_A (){}
72. ~ Seed_A (){}
74. Void Accept (Status * vis)
75. {
76. Vis-> VisitSeed_A (this );
77. }
78. };
80. // Seed B, which is assumed to be the seed from space
81. Class Seed_ B: public Seed
82. {
83. Public:
84. Seed_ B (){}
85. ~ Seed_ B (){}
87. Void Accept (Status * vis)
88. {
89. Vis-> VisitSeed_ B (this );
90. }
91. };
94. // Object structure class, in order to compare different seeds
95. Class ObjectStructure
96. {
97. Private:
98. List Lseed;
100. Public:
101. // Add
102. Void Attach (Seed * seed)
103. {
104. Lseed. push_back (seed );
105. }
107. // Delete
108. Void Detach (Seed * seed)
109. {
110. Lseed. remove (seed );
111. }
113. // Show
114. Void Display (Status * status)
115. {
116. List : Iterator it = lseed. begin ();
118. For (it; it! = Lseed. end (); ++ it)
119. {
120. (* It)-> Accept (status );
121. }
122. }
123. };
126. // Test code
127. Int main (int argc, char * argv [])
128. {
129. ObjectStructure obj;
131. // Add two seeds to be compared
132. Obj. Attach (new Seed_A ());
133. Obj. Attach (new Seed_ B ());
135. // View the status of two seeds in various states
136. Obj. Display (new Rain_Status ());
138. // Sun Satte
139. Obj. Display (new Sun_Status ());
141. Return 0;
142. }

     Iii. Description

     1.First, we need to make it clear that the two seeds will not change easily, that is, only the common and space seeds. In other words, the data structure is relatively stable.

     2.It can be changed to the new State, such as the generation of an X-ray. To put it bluntly, the operation set can evolve freely.

     3.The advantage of this structure is that it is easy to add new operations. The disadvantage is that it is difficult to add new data structures because you need to add corresponding operations to every visitor.

     4.The seed growth chart has the following relationship with the structure of the visitor mode:

     Seed (seed) is equivalent to element, which is not quite changed.
     

     Status is equivalent to visitor, Which is variable and changeable. Note that each visitor must operate on all elements.

     5.In fact, we seldom use this mode because the data structure (element) remains unchanged.