访问者模式（Visitor Pattern）是行为型设计模式的核心范式之一，核心思想是分离数据结构与数据操作，在不修改现有数据结构的前提下，灵活扩展新的操作逻辑。该模式通过引入“访问者”角色，将对数据的操作封装为独立实体，让数据结构专注于数据存储，操作逻辑专注于业务处理，尤其适用于数据结构稳定但操作频繁变化的场景。本文将从核心结构、多语言落地实现、优缺点剖析、适用场景及实战总结等维度，系统拆解访问者模式的设计思路与工程实践，为开发者提供可直接复用的技术方案。
一、访问者模式核心结构
访问者模式的核心是通过五大角色的协同，实现“数据与操作”的解耦，各角色职责边界清晰、分工明确，共同构成完整的设计闭环。理解各角色的作用与交互逻辑，是掌握该模式的关键，具体定义如下：
1.1 抽象元素（Element）
抽象元素是数据结构的抽象契约，定义了一个核心方法——接受访问者的Accept方法。该方法的核心作用是将自身作为参数，传递给访问者，触发访问者对当前元素的具体操作，是元素与访问者建立关联的桥梁。
1.2 具体元素（ConcreteElement）
具体元素是抽象元素的具象化实现，负责存储具体数据，并实现Accept方法。其核心逻辑是：在Accept方法中调用访问者对应的访问方法，将自身实例传递给访问者，完成操作的委托执行，确保访问者能获取元素的内部数据并执行处理。
1.3 抽象访问者（Visitor）
抽象访问者是操作逻辑的抽象契约，为每一种具体元素类型声明一个对应的访问方法（如VisitConcreteElementA）。访问方法的参数为对应类型的具体元素，确保访问者能精准操作不同类型的元素，同时规范所有具体访问者的实现标准。
1.4 具体访问者（ConcreteVisitor）
具体访问者是抽象访问者的具象化实现，负责实现抽象访问者声明的所有访问方法，定义对不同具体元素的差异化操作逻辑。一个具体访问者对应一套完整的操作逻辑，新增操作只需新增具体访问者，无需修改现有代码。
1.5 对象结构（ObjectStructure）
对象结构是元素的容器，负责管理所有具体元素的集合，提供元素的添加、删除和遍历方法。其核心作用是统一接收访问者，遍历所有元素并触发元素的Accept方法，让访问者能批量处理集合中的所有元素，简化客户端调用逻辑。
核心交互逻辑：客户端创建对象结构→添加具体元素→创建具体访问者→对象结构接收访问者→遍历元素，触发元素Accept方法→元素调用访问者对应方法→访问者执行具体操作。
二、多语言实现访问者模式
以“数据处理工具”为统一实战场景，设计两类具体元素（ConcreteElementA存储基础数值，ConcreteElementB存储运算数值），两类具体访问者（基础数据查看、数据运算处理），通过对象结构管理元素集合。以下提供C#、Python、Golang、C++及纯C的可运行实现，贴合各语言原生特性，补充规范注释与边界校验，兼顾实用性与严谨性，清晰呈现模式适配思路。
2.1 C# 实现（面向对象规范实现）
C#作为强类型面向对象语言，通过接口定义抽象元素与抽象访问者，依托多态特性实现操作的动态分发，代码结构清晰、可维护性高，适用于企业级业务系统中“数据结构固定、操作易扩展”的场景（如报表生成、数据统计）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
| using System;
using System.Collections.Generic;
public interface IVisitor
{
void VisitConcreteElementA(ConcreteElementA elementA);
void VisitConcreteElementB(ConcreteElementB elementB);
}
public class ConcreteVisitor1 : IVisitor
{
public void VisitConcreteElementA(ConcreteElementA elementA)
{
Console.WriteLine($"【{GetType().Name}】处理 {elementA.GetType().Name}，原始数据：{elementA.Data}");
}
public void VisitConcreteElementB(ConcreteElementB elementB)
{
Console.WriteLine($"【{GetType().Name}】处理 {elementB.GetType().Name}，原始数据：{elementB.Value}");
}
}
public class ConcreteVisitor2 : IVisitor
{
public void VisitConcreteElementA(ConcreteElementA elementA)
{
int result = elementA.Data * 2;
Console.WriteLine($"【{GetType().Name}】处理 {elementA.GetType().Name}，数据翻倍结果：{result}");
}
public void VisitConcreteElementB(ConcreteElementB elementB)
{
int result = elementB.Value * elementB.Value;
Console.WriteLine($"【{GetType().Name}】处理 {elementB.GetType().Name}，数据平方结果：{result}");
}
}
public interface IElement
{
void Accept(IVisitor visitor);
}
public class ConcreteElementA : IElement
{
public int Data { get; set; } = 10;
public void Accept(IVisitor visitor)
{
visitor.VisitConcreteElementA(this);
}
}
public class ConcreteElementB : IElement
{
public int Value { get; set; } = 5;
public void Accept(IVisitor visitor)
{
visitor.VisitConcreteElementB(this);
}
}
public class ObjectStructure
{
private readonly List<IElement> _elements = new List<IElement>();
public void AddElement(IElement element)
{
if (element == null)
{
Console.WriteLine("警告：添加的元素不可为null");
return;
}
_elements.Add(element);
}
public void Accept(IVisitor visitor)
{
if (visitor == null)
{
Console.WriteLine("警告：访问者不可为null");
return;
}
foreach (var element in _elements)
{
element.Accept(visitor);
}
}
}
class Program
{
static void Main(string[] args)
{
try
{
ObjectStructure structure = new ObjectStructure();
structure.AddElement(new ConcreteElementA());
structure.AddElement(new ConcreteElementB());
IVisitor visitor1 = new ConcreteVisitor1();
Console.WriteLine("=== 执行基础数据查看操作 ===");
structure.Accept(visitor1);
IVisitor visitor2 = new ConcreteVisitor2();
Console.WriteLine("\n=== 执行数据运算处理操作 ===");
structure.Accept(visitor2);
}
catch (Exception ex)
{
Console.WriteLine($"执行异常：{ex.Message}");
}
}
}
|
2.2 Python 实现（动态语言简洁实现）
Python遵循“鸭子类型”，无需显式定义接口，通过抽象基类（ABC）约定元素与访问者的行为，语法简洁、无冗余类型声明。依托动态特性，可灵活扩展元素与访问者，无需严格的类型校验，适用于快速开发、轻量级项目（如数据处理脚本）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
| from abc import ABC, abstractmethod
class Visitor(ABC):
"""抽象访问者：通过抽象方法约定访问行为"""
@abstractmethod
def visit_concrete_element_a(self, element):
"""访问具体元素A"""
pass
@abstractmethod
def visit_concrete_element_b(self, element):
"""访问具体元素B"""
pass
class ConcreteVisitor1(Visitor):
"""具体访问者1：基础数据查看操作"""
def visit_concrete_element_a(self, element):
print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，原始数据：{element.data}")
def visit_concrete_element_b(self, element):
print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，原始数据：{element.value}")
class ConcreteVisitor2(Visitor):
"""具体访问者2：数据运算处理操作"""
def visit_concrete_element_a(self, element):
result = element.data * 2
print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，数据翻倍结果：{result}")
def visit_concrete_element_b(self, element):
result = element.value ** 2
print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，数据平方结果：{result}")
class Element(ABC):
"""抽象元素：约定接受访问者的方法"""
@abstractmethod
def accept(self, visitor):
"""接受访问者访问"""
pass
class ConcreteElementA(Element):
"""具体元素A：存储基础数值数据"""
def __init__(self):
self.data = 10
def accept(self, visitor):
visitor.visit_concrete_element_a(self)
class ConcreteElementB(Element):
"""具体元素B：存储运算数值数据"""
def __init__(self):
self.value = 5
def accept(self, visitor):
visitor.visit_concrete_element_b(self)
class ObjectStructure:
"""对象结构：管理元素集合，提供批量访问入口"""
def __init__(self):
self.elements = []
def add_element(self, element):
"""添加元素到集合，校验元素合法性"""
if not isinstance(element, Element):
raise TypeError("添加的元素必须是Element子类实例")
self.elements.append(element)
def accept(self, visitor):
"""接受访问者，遍历所有元素执行操作"""
if not isinstance(visitor, Visitor):
raise TypeError("访问者必须是Visitor子类实例")
for element in self.elements:
element.accept(visitor)
if __name__ == "__main__":
try:
structure = ObjectStructure()
structure.add_element(ConcreteElementA())
structure.add_element(ConcreteElementB())
visitor1 = ConcreteVisitor1()
print("=== 执行基础数据查看操作 ===")
structure.accept(visitor1)
visitor2 = ConcreteVisitor2()
print("\n=== 执行数据运算处理操作 ===")
structure.accept(visitor2)
except Exception as e:
print(f"执行异常：{str(e)}")
|
2.3 Golang 实现（接口至上轻量实现）
Go语言无类和继承，遵循“组合优于继承”原则，通过接口定义抽象元素与抽象访问者的契约，结构体实现接口方法完成具体逻辑。依托接口隐式实现特性，代码极简高效，贴合Go语言设计理念，适配高并发后端场景（如数据批量处理、中间件扩展）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
| package main
import "fmt"
type Visitor interface {
VisitConcreteElementA(element *ConcreteElementA)
VisitConcreteElementB(element *ConcreteElementB)
}
type ConcreteVisitor1 struct{}
func (v *ConcreteVisitor1) VisitConcreteElementA(element *ConcreteElementA) {
fmt.Printf("【ConcreteVisitor1】处理 ConcreteElementA，原始数据：%d\n", element.Data)
}
func (v *ConcreteVisitor1) VisitConcreteElementB(element *ConcreteElementB) {
fmt.Printf("【ConcreteVisitor1】处理 ConcreteElementB，原始数据：%d\n", element.Value)
}
type ConcreteVisitor2 struct{}
func (v *ConcreteVisitor2) VisitConcreteElementA(element *ConcreteElementA) {
result := element.Data * 2
fmt.Printf("【ConcreteVisitor2】处理 ConcreteElementA，数据翻倍结果：%d\n", result)
}
func (v *ConcreteVisitor2) VisitConcreteElementB(element *ConcreteElementB) {
result := element.Value * element.Value
fmt.Printf("【ConcreteVisitor2】处理 ConcreteElementB，数据平方结果：%d\n", result)
}
type Element interface {
Accept(visitor Visitor)
}
type ConcreteElementA struct {
Data int
}
func (e *ConcreteElementA) Accept(visitor Visitor) {
visitor.VisitConcreteElementA(e)
}
type ConcreteElementB struct {
Value int
}
func (e *ConcreteElementB) Accept(visitor Visitor) {
visitor.VisitConcreteElementB(e)
}
type ObjectStructure struct {
elements []Element
}
func (os *ObjectStructure) AddElement(element Element) {
if element == nil {
fmt.Println("警告：添加的元素不可为nil")
return
}
os.elements = append(os.elements, element)
}
func (os *ObjectStructure) Accept(visitor Visitor) {
if visitor == nil {
fmt.Println("警告：访问者不可为nil")
return
}
for _, element := range os.elements {
element.Accept(visitor)
}
}
func main() {
structure := &ObjectStructure{}
structure.AddElement(&ConcreteElementA{Data: 10})
structure.AddElement(&ConcreteElementB{Value: 5})
visitor1 := &ConcreteVisitor1{}
fmt.Println("=== 执行基础数据查看操作 ===")
structure.Accept(visitor1)
visitor2 := &ConcreteVisitor2{}
fmt.Println("\n=== 执行数据运算处理操作 ===")
structure.Accept(visitor2)
}
|
2.4 C++ 实现（抽象类+多态经典实现）
C++通过抽象类（纯虚函数）定义抽象元素与抽象访问者，子类继承并实现具体逻辑，依托多态特性实现操作的动态分发，是访问者模式的经典实现方式。需手动管理内存（虚析构函数避免内存泄漏），兼顾灵活性与高性能，适用于底层开发、高频调用场景（如编译器语法树处理、嵌入式数据解析）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
| #include <iostream>
#include <vector>
using namespace std;
class ConcreteElementA;
class ConcreteElementB;
class Visitor {
public:
virtual ~Visitor() = default;
virtual void VisitConcreteElementA(ConcreteElementA* element) = 0;
virtual void VisitConcreteElementB(ConcreteElementB* element) = 0;
};
class ConcreteVisitor1 : public Visitor {
public:
void VisitConcreteElementA(ConcreteElementA* element) override;
void VisitConcreteElementB(ConcreteElementB* element) override;
};
class ConcreteVisitor2 : public Visitor {
public:
void VisitConcreteElementA(ConcreteElementA* element) override;
void VisitConcreteElementB(ConcreteElementB* element) override;
};
class Element {
public:
virtual ~Element() = default;
virtual void Accept(Visitor* visitor) = 0;
};
class ConcreteElementA : public Element {
public:
int data = 10;
void Accept(Visitor* visitor) override {
visitor->VisitConcreteElementA(this);
}
};
class ConcreteElementB : public Element {
public:
int value = 5;
void Accept(Visitor* visitor) override {
visitor->VisitConcreteElementB(this);
}
};
void ConcreteVisitor1::VisitConcreteElementA(ConcreteElementA* element) {
cout << "【ConcreteVisitor1】处理 ConcreteElementA，原始数据：" << element->data << endl;
}
void ConcreteVisitor1::VisitConcreteElementB(ConcreteElementB* element) {
cout << "【ConcreteVisitor1】处理 ConcreteElementB，原始数据：" << element->value << endl;
}
void ConcreteVisitor2::VisitConcreteElementA(ConcreteElementA* element) {
int result = element->data * 2;
cout << "【ConcreteVisitor2】处理 ConcreteElementA，数据翻倍结果：" << result << endl;
}
void ConcreteVisitor2::VisitConcreteElementB(ConcreteElementB* element) {
int result = element->value * element->value;
cout << "【ConcreteVisitor2】处理 ConcreteElementB，数据平方结果：" << result << endl;
}
class ObjectStructure {
private:
vector<Element*> elements;
public:
~ObjectStructure() {
for (auto elem : elements) {
delete elem;
elem = nullptr;
}
}
void AddElement(Element* element) {
if (element == nullptr) {
cout << "警告：添加的元素不可为nullptr" << endl;
return;
}
elements.push_back(element);
}
void Accept(Visitor* visitor) {
if (visitor == nullptr) {
cout << "警告：访问者不可为nullptr" << endl;
return;
}
for (auto elem : elements) {
elem->Accept(visitor);
}
}
};
int main() {
try {
ObjectStructure* structure = new ObjectStructure();
structure->AddElement(new ConcreteElementA());
structure->AddElement(new ConcreteElementB());
Visitor* visitor1 = new ConcreteVisitor1();
cout << "=== 执行基础数据查看操作 ===" << endl;
structure->Accept(visitor1);
Visitor* visitor2 = new ConcreteVisitor2();
cout << "\n=== 执行数据运算处理操作 ===" << endl;
structure->Accept(visitor2);
delete visitor1;
delete visitor2;
visitor1 = nullptr;
visitor2 = nullptr;
delete structure;
structure = nullptr;
} catch (const exception& e) {
cout << "执行异常：" << e.what() << endl;
}
return 0;
}
|
2.5 纯C语言实现（结构体+函数指针模拟实现）
纯C无面向对象特性，通过“结构体封装数据+函数指针封装行为”模拟访问者模式的核心逻辑。结构体封装元素与访问者的属性，函数指针模拟抽象方法，底层可控性强、无额外依赖，适用于嵌入式、底层开发等资源受限场景，完整还原模式“数据与操作分离”的核心思想。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct ConcreteElementA ConcreteElementA;
typedef struct ConcreteElementB ConcreteElementB;
typedef struct Visitor Visitor;
typedef struct Element Element;
typedef void (*VisitConcreteElementAFunc)(Visitor* visitor, ConcreteElementA* element);
typedef void (*VisitConcreteElementBFunc)(Visitor* visitor, ConcreteElementB* element);
typedef struct Visitor {
VisitConcreteElementAFunc visit_concrete_element_a;
VisitConcreteElementBFunc visit_concrete_element_b;
char name[20];
} Visitor;
typedef struct ConcreteElementA {
int data;
void (*accept)(ConcreteElementA* element, Visitor* visitor);
} ConcreteElementA;
typedef struct ConcreteElementB {
int value;
void (*accept)(ConcreteElementB* element, Visitor* visitor);
} ConcreteElementB;
typedef struct Element {
enum { ELEMENT_A, ELEMENT_B } type;
void* data;
void (*accept)(void* element, Visitor* visitor);
} Element;
void concrete_visitor1_visit_a(Visitor* visitor, ConcreteElementA* element) {
if (visitor == NULL || element == NULL) return;
printf("【%s】处理 ConcreteElementA，原始数据：%d\n", visitor->name, element->data);
}
void concrete_visitor1_visit_b(Visitor* visitor, ConcreteElementB* element) {
if (visitor == NULL || element == NULL) return;
printf("【%s】处理 ConcreteElementB，原始数据：%d\n", visitor->name, element->value);
}
void concrete_visitor2_visit_a(Visitor* visitor, ConcreteElementA* element) {
if (visitor == NULL || element == NULL) return;
int result = element->data * 2;
printf("【%s】处理 ConcreteElementA，数据翻倍结果：%d\n", visitor->name, result);
}
void concrete_visitor2_visit_b(Visitor* visitor, ConcreteElementB* element) {
if (visitor == NULL || element == NULL) return;
int result = element->value * element->value;
printf("【%s】处理 ConcreteElementB，数据平方结果：%d\n", visitor->name, result);
}
void concrete_element_a_accept(ConcreteElementA* element, Visitor* visitor) {
if (element == NULL || visitor == NULL) return;
visitor->visit_concrete_element_a(visitor, element);
}
void concrete_element_b_accept(ConcreteElementB* element, Visitor* visitor) {
if (element == NULL || visitor == NULL) return;
visitor->visit_concrete_element_b(visitor, element);
}
void element_accept(void* elem, Visitor* visitor) {
if (elem == NULL || visitor == NULL) return;
Element* element = (Element*)elem;
if (element->type == ELEMENT_A) {
ConcreteElementA* a = (ConcreteElementA*)element->data;
a->accept(a, visitor);
} else if (element->type == ELEMENT_B) {
ConcreteElementB* b = (ConcreteElementB*)element->data;
b->accept(b, visitor);
}
}
typedef struct ObjectStructure {
Element** elements;
int count;
int capacity;
} ObjectStructure;
ObjectStructure* object_structure_init(int capacity) {
if (capacity <= 0) return NULL;
ObjectStructure* os = (ObjectStructure*)malloc(sizeof(ObjectStructure));
if (os == NULL) return NULL;
os->elements = (Element**)malloc(sizeof(Element*) * capacity);
if (os->elements == NULL) {
free(os);
return NULL;
}
os->count = 0;
os->capacity = capacity;
return os;
}
void object_structure_add(ObjectStructure* os, Element* element) {
if (os == NULL || element == NULL || os->count >= os->capacity) return;
os->elements[os->count++] = element;
}
void object_structure_accept(ObjectStructure* os, Visitor* visitor) {
if (os == NULL || visitor == NULL) return;
for (int i = 0; i < os->count; i++) {
os->elements[i]->accept(os->elements[i], visitor);
}
}
void object_structure_free(ObjectStructure* os) {
if (os == NULL) return;
for (int i = 0; i < os->count; i++) {
free(os->elements[i]->data);
free(os->elements[i]);
}
free(os->elements);
free(os);
}
int main() {
Visitor visitor1 = {
.visit_concrete_element_a = concrete_visitor1_visit_a,
.visit_concrete_element_b = concrete_visitor1_visit_b,
.name = "ConcreteVisitor1"
};
Visitor visitor2 = {
.visit_concrete_element_a = concrete_visitor2_visit_a,
.visit_concrete_element_b = concrete_visitor2_visit_b,
.name = "ConcreteVisitor2"
};
ConcreteElementA* elemA = (ConcreteElementA*)malloc(sizeof(ConcreteElementA));
if (elemA == NULL) return -1;
elemA->data = 10;
elemA->accept = concrete_element_a_accept;
Element* elementA = (Element*)malloc(sizeof(Element));
if (elementA == NULL) {
free(elemA);
return -1;
}
elementA->type = ELEMENT_A;
elementA->data = elemA;
elementA->accept = element_accept;
ConcreteElementB* elemB = (ConcreteElementB*)malloc(sizeof(ConcreteElementB));
if (elemB == NULL) {
free(elementA);
free(elemA);
return -1;
}
elemB->value = 5;
elemB->accept = concrete_element_b_accept;
Element* elementB = (Element*)malloc(sizeof(Element));
if (elementB == NULL) {
free(elemB);
free(elementA);
free(elemA);
return -1;
}
elementB->type = ELEMENT_B;
elementB->data = elemB;
elementB->accept = element_accept;
ObjectStructure* structure = object_structure_init(2);
if (structure == NULL) {
free(elementB);
free(elemB);
free(elementA);
free(elemA);
return -1;
}
object_structure_add(structure, elementA);
object_structure_add(structure, elementB);
printf("=== 执行基础数据查看操作 ===\n");
object_structure_accept(structure, &visitor1);
printf("\n=== 执行数据运算处理操作 ===\n");
object_structure_accept(structure, &visitor2);
object_structure_free(structure);
return 0;
}
|
三、访问者模式的优缺点
访问者模式的核心价值是实现“数据与操作的解耦”，其优势集中在操作的灵活扩展，而局限则体现在元素扩展的困难性。实际开发中需结合业务场景权衡使用，平衡设计优雅与工程落地成本，避免过度设计。
3.1 核心优点
操作扩展灵活，符合开闭原则：新增操作只需新增具体访问者，无需修改现有元素代码，大幅降低扩展成本。例如，新增“数据格式化”操作，仅需实现一个新的具体访问者，无需改动元素和对象结构。
操作逻辑集中，便于维护复用：同一类操作逻辑集中在一个具体访问者中，避免操作逻辑分散在多个元素中，提升代码可读性和可维护性，同时便于同类操作的复用。
分离数据与操作，降低耦合：数据结构（元素）专注于数据存储，操作逻辑（访问者）独立管理，打破数据与操作的强关联，让代码结构更清晰，符合“单一职责原则”。
支持多态遍历，简化复杂处理：通过访问者可实现对不同类型元素的差异化处理，无需在客户端编写大量条件判断，简化复杂集合的遍历与处理逻辑。
3.2 主要缺点
元素扩展困难，违反开闭原则：新增具体元素时，需修改所有抽象访问者和具体访问者的代码，添加对应的访问方法，大幅增加扩展成本，不适用于元素频繁变化的场景。
破坏元素封装性：访问者需要访问元素的内部数据（如私有属性）才能执行操作，可能暴露元素的实现细节，破坏面向对象的封装性。
代码复杂度提升，理解成本高：模式引入五大角色，且元素与访问者之间存在双向依赖，增加代码的复杂度和理解难度，不利于新手维护。
面向过程语言适配性差：纯C等面向过程语言需通过复杂的结构体和函数指针模拟面向对象特性，实现代码繁琐、可读性低，增加开发和调试成本。
四、访问者模式的使用场景
访问者模式的适用场景具有明确的前提：数据结构稳定，操作频繁变化。以下结合具体业务场景与实战案例，帮助开发者精准判断适用性，避免滥用。
4.1 核心适用场景
数据结构稳定，操作易变的场景：最典型的场景是编译器的语法树（AST），语法树结构固定，但需支持类型检查、代码生成、语法优化、错误检测等多种操作，新增操作只需新增访问者。
跨元素的统一操作场景：对不同类型的对象执行统一的批量操作，如对文本、图片、视频等不同类型文件，执行备份、压缩、加密等操作，每种操作对应一个访问者。
复杂集合的遍历与差异化处理场景：如电商系统中，对订单、商品、用户等不同实体，执行数据统计、报表生成、权限校验等操作，通过访问者实现差异化处理。
框架/库的扩展场景：如ORM框架中，对不同数据库（MySQL、PostgreSQL、Oracle）执行增删改查操作，每种数据库的操作逻辑封装为一个访问者，便于扩展新数据库。
4.2 不适用场景
元素类型频繁变化的场景（如频繁新增、删除元素），会导致访问者代码频繁修改，违反开闭原则。
元素封装性要求极高的场景，访问者需要访问元素内部数据，会破坏封装。
简单操作场景（仅需1-2种操作），使用访问者模式会增加代码复杂度，直接调用方法更高效。
五、总结
访问者模式的核心价值在于分离数据结构与数据操作，其设计初衷是解决“数据结构稳定但操作易变”的问题，通过引入访问者角色，实现操作的灵活扩展，同时让数据结构专注于自身职责。不同语言对该模式的实现方式差异显著，但核心思想一致：
面向对象语言（C#、Python、Golang、C++）可通过接口/抽象类直接适配，依托多态特性实现操作的动态分发，代码结构清晰、可维护性高；纯C语言则需通过结构体+函数指针模拟面向对象特性，虽实现繁琐，但能在资源受限场景中还原模式核心逻辑。
使用访问者模式时，需明确核心前提：数据结构是否稳定、操作是否频繁变化。若元素类型频繁变化，应避免使用；若操作逻辑频繁扩展，访问者模式能显著降低代码耦合，提升扩展能力。在实际开发中，需摒弃“为了使用设计模式而使用”的思维，结合业务场景合理选择，在设计优雅与代码可读性、可维护性之间找到平衡，让设计模式真正服务于工程实践。