訪問者模式(Visitor):表示一個作用於某物件結構中各元素的操作。它讓你可以在不改變各元素類別的前提下,定義作用於這些元素的新操作。
類結構圖如下:

它適用於資料結構相對穩定的系統:把資料結構與作用於其上的操作解耦,讓操作得以相對自由地演化。
換句話說,訪問者模式把「處理」從「資料結構」中分離出來。若一個系統有穩定的資料結構、又有易於變化的演算法,那麼它就是理想場景——因為新增操作變得容易。
優點很明確:新增操作只需多寫一個訪問者,而且相關行為集中在同一個物件裡。缺點同樣明確:新增資料結構變得很痛苦,因為得改動所有訪問者。GoF 其中一位作者曾說過:「大多時候你並不需要訪問者模式,但當你真的需要它時,就是真的需要。」
假設有一輛車,含 1 台引擎、4 個輪子。我們要為它加上「升級」與「維修」兩種操作。
NimoEngine.h / .m
#import <Foundation/Foundation.h> @interface NimoEngine : NSObject @property (nonatomic, copy) NSString *modelName; - (id)initWithModelName:(NSString *)modelName; @end
#import "NimoEngine.h"
@implementation NimoEngine
- (id)initWithModelName:(NSString *)modelName {
self = [super init];
if (self) { _modelName = [modelName copy]; }
return self;
}
- (id)init {
return [self initWithModelName:@"Slant 6"];
}
- (NSString *)description {
return [NSString stringWithFormat:@"Engine: %@", _modelName];
}
@end
NimoWheel.h / .m
@interface NimoWheel : NSObject @property (nonatomic, assign) float diameter; // 輪徑 @end
#import "NimoWheel.h"
@implementation NimoWheel
- (id)init {
self = [super init];
if (self) { _diameter = 400.0f; }
return self;
}
- (NSString *)description {
return [NSString stringWithFormat:@"Wheel: %f mm", _diameter];
}
@end
NimoCar.h / .m
@class NimoEngine, NimoWheel; @interface NimoCar : NSObject @property (nonatomic) NimoEngine *engine; @property (nonatomic, readonly) NSArray *arrayOfWheels; - (void)addWheel:(NimoWheel *)wheel atIndex:(NSUInteger)index; @end
@interface NimoCar ()
@property (nonatomic, readwrite) NSMutableArray *mutableArrayOfWheels;
@end
@implementation NimoCar
- (id)init {
if (self = [super init]) {
_mutableArrayOfWheels = [[NSMutableArray alloc] initWithCapacity:4];
}
return self;
}
- (void)addWheel:(NimoWheel *)wheel atIndex:(NSUInteger)index {
[_mutableArrayOfWheels insertObject:wheel atIndex:index];
}
// 對外只暴露不可變陣列,避免外部直接改動內部狀態
- (NSArray *)arrayOfWheels {
return [_mutableArrayOfWheels copy];
}
- (NSString *)description {
return [NSString stringWithFormat:@"My car: %@",
[NSDictionary dictionaryWithObjects:@[_engine, self.arrayOfWheels]
forKeys:@[@"Engine", @"Wheels"]]];
}
@end
結構很單純,各類只覆寫了 description 以便輸出資訊。實體化一輛車看看:
int main(int argc, const char * argv[]) {
@autoreleasepool {
NimoCar *car = [[NimoCar alloc] init];
NimoEngine *engine = [[NimoEngine alloc] initWithModelName:@"V8"];
NimoWheel *wheelA = [[NimoWheel alloc] init];
NimoWheel *wheelB = [[NimoWheel alloc] init];
NimoWheel *wheelC = [[NimoWheel alloc] init];
NimoWheel *wheelD = [[NimoWheel alloc] init];
car.engine = engine;
[car addWheel:wheelA atIndex:0];
[car addWheel:wheelB atIndex:1];
[car addWheel:wheelC atIndex:2];
[car addWheel:wheelD atIndex:3];
NSLog(@"%@", car);
}
return 0;
}

控制台如預期輸出了車輛資訊。準備工作完成。
回到定義那句話:NimoCar 是物件結構,其中的元素是 NimoEngine 與 NimoWheel。現在需要對車進行「全面升級」。
直覺做法是在 NimoEngine 與 NimoWheel 各開一個 upgrade 介面。接著需求變成「維修」,又得各開一個 repair 介面。再來是「保養」、「改裝」、「檢測」……需求越多,元素類別對外暴露的介面就越多,類別也越來越腫。
有沒有更單純的做法?有——把這些瑣事都交給訪問者,元素類別只要同意被訪問就行。
@class NimoEngine, NimoWheel; @protocol NimoComponentVisitor <NSObject> - (void)visitEngine:(NimoEngine *)engine; - (void)visitWheel:(NimoWheel *)wheel; @end
三個類別都加上同一個方法:
// NimoEngine
- (void)acceptComponentVisitor:(id<NimoComponentVisitor>)visitor {
[visitor visitEngine:self];
}
// NimoWheel
- (void)acceptComponentVisitor:(id<NimoComponentVisitor>)visitor {
[visitor visitWheel:self];
}
// NimoCar:把訪問動作傳遞給內部所有元素
- (void)acceptComponentVisitor:(id<NimoComponentVisitor>)visitor {
[_engine acceptComponentVisitor:visitor];
for (NimoWheel *wheel in self.arrayOfWheels) {
[wheel acceptComponentVisitor:visitor];
}
}
這裡有個關鍵設計:NimoCar 自己沒有被訪問的方法,而是把職責往下分發給引擎與輪子。這正是「物件結構」與「元素」的分工——結構負責遍歷,元素負責接收。
而 acceptComponentVisitor: 中呼叫 visitEngine: 還是 visitWheel:,是由元素的實際型別決定的。這就是所謂的雙重分派(Double Dispatch):Objective-C 不像某些語言支援函式多載,靠這層間接呼叫模擬出「依型別分派」的能力。
升級人員
@interface NimoComponentUpgrade : NSObject <NimoComponentVisitor>
@end
@implementation NimoComponentUpgrade
- (void)visitEngine:(NimoEngine *)engine {
NSLog(@"我是升級人員,正在對引擎<%@>進行升級", engine);
}
- (void)visitWheel:(NimoWheel *)wheel {
NSLog(@"我是升級人員,正在對車輪<%@>進行升級", wheel);
}
@end
執行看看:
// 對組件進行「升級」 NimoComponentUpgrade *upgradeVisitor = [[NimoComponentUpgrade alloc] init]; [car acceptComponentVisitor:upgradeVisitor];

看來這位訪問者工作得很稱職。
現在需求變成「維修」——不必碰任何元素類別,只要多一個訪問者:
@interface NimoComponentMaintenance : NSObject <NimoComponentVisitor>
@end
@implementation NimoComponentMaintenance
- (void)visitEngine:(NimoEngine *)engine {
NSLog(@"我是維修人員,正在對引擎<%@>進行維修", engine);
}
- (void)visitWheel:(NimoWheel *)wheel {
NSLog(@"我是維修人員,正在對車輪<%@>進行維修", wheel);
}
@end
// 對組件進行「維修」 NimoComponentMaintenance *maintenanceVisitor = [[NimoComponentMaintenance alloc] init]; [car acceptComponentVisitor:maintenanceVisitor];
元素類別一行程式碼都沒改,新的操作就加完了。
判斷標準其實很清晰:資料結構幾乎不會變,但操作會不斷增加。編譯器的 AST 走訪、文件物件模型的各種轉出(轉 HTML、轉 PDF、語法高亮)、報表的多維統計,都是典型的適用場景。
反過來,如果你的元素型別本身還在頻繁增刪,那麼訪問者模式只會讓每次改動都得回頭修改所有訪問者,得不偿失。這時用一般的多型(在元素上定義方法)反而更合適。