當人們初學 Cocoa/Objective-C 時，Objective-C Runtime 是被忽略的特性之一。原因是 Objective-C（這門語言）很容易在幾小時內就熟悉，新學 Cocoa 的人花費他們大部分的時間學習 Cocoa 框架和適應它是如何工作的。然而每個人至少應該知道一些 runtime 的工作細節，需要比知道編譯器會把 [target doMethodWith:var1]; 轉換爲 objc_msgSend(target,@selector(doMethodWith:),var1); 更深入一些。知道 Objective-C 正在做的會讓你更深入的理解 Objective-C 和你正在運行的 app。我認爲 Mac/iPhone 的開發者不管你現在是什麼水平，都會有收穫的。

Objective-C Runtime 是開源的

Objective-C 是開源的，任何時候你都能從 http://opensource.apple.com. 獲取。事實上查看 Objective-C 源碼是我理解它是如何工作的第一種方式，在這個問題上要比讀蘋果的文檔要好。你可以下載適合 Mac OS X 10.6.2 的 objc4-437.1.tar.gz。（譯註：最新objc4-551.1.tar.gz）

動態 vs 靜態語言

Objective-C 是面相運行時的語言（runtime oriented language），就是說它會盡可能的把編譯和鏈接時要執行的邏輯延遲到運行時。這就給了你很大的靈活性，你可以按需要把消息重定向給合適的對象，你甚至可以交換方法的實現，等等（譯註：在 Objective-C 中調用一個對象的方法可以看成向一個對象發送消息, Method Swizzling 具體實現可以參看 jrswizzle ）。這就需要使用 runtime，runtime 可以做對象自省查看他們正在做的和不能做的（don’t respond to）並且合適的分發消息（譯註：感興趣的同學可以查看 NSObject 類的 – forwardingTargetForSelector: 和 – forwardInvocation: 方法。P.S. 不是 NSObject 協議！）。如果我們和 C 這樣的語言對比。在 C 裏，你從 main() 方法開始寫然後就是從上到下的寫邏輯了並按你寫代碼的順序執行程序。一個 C 的結構體不能轉發函數執行請求到其他的目標上（other targets）。很可能你的程序是這樣的：

include

int main(int argc, const char **argv[])
{
printf(“Hello World!”);
return 0;
}
編譯器解析，優化然後把優化後的代碼轉成彙編：

.text
.align 4,0x90
.globl _main
_main:
Leh_func_begin1:
pushq %rbp
Llabel1:
movq %rsp, %rbp
Llabel2:
subq 16,Llabel3:movqmovlmovlmovqxorbleaqLC(movqcallprintfmovl 0, -4(%rbp)
movl -4(%rbp), %eax
addq $16, %rsp
popq %rbp
ret
Leh_func_end1:
.cstring
LC:
.asciz “Hello World!”
然後鏈接庫並生成可執行程序（譯註：如果你對 C 的編譯鏈接過程還不熟悉可以參看 Deep C and C++）。要和 Objective-C 對比的話，處理過程很相似，生成的代碼依賴於是否有 Objective-C Runtime 庫。當剛學 Objective-C 時，我們最先了解的(最簡單的那種)是 Objective-C 中用括號包起來的代碼像這樣…

1
[self doSomethingWithVar:var1];
被轉換爲…

1
objc_msgSend(self,@selector(doSomethingWithVar:),var1);
但除了這些，我們就不知道之後在運行時做了什麼了。

Objective-C Runtime 是什麼？

Objective-C 的 Runtime 是一個運行時庫（Runtime Library），它是一個主要使用 C 和彙編寫的庫，爲 C 添加了面相對象的能力並創造了 Objective-C。這就是說它在類信息（Class information）中被加載，完成所有的方法分發，方法轉發，等等。Objective-C runtime 創建了所有需要的結構體，讓 Objective-C 的面相對象編程變爲可能。

Objective-C Runtime 術語

更深入之前，咱們先了解點術語。Mac 和 iPhone 開發者關心的有兩個 runtime：Modern Runtime（現代的 Runtime）和 Legacy Runtime（過時的 Runtime）。Modern Runtime：覆蓋所有 64 位的 Mac OS X 應用和所有 iPhone OS 的應用。 Legacy Runtime: 覆蓋其他的所有應用（所有 32 位的 Mac OS X 應用） Method 有 2 種基本類型的方法。Instance Method（實例方法）：以 ‘-’ 開始，比如 -(void)doFoo; 在對象實例上操作。Class Method（類方法）：以 ‘+’ 開始，比如 +(id)alloc。方法（Methods）和 C 的函數很像，是一組代碼，執行一個小的任務，如：

(NSString *)movieTitle
{
return @”Futurama: Into the Wild Green Yonder”;
}
Selector 在 Objective-C 中 selector 只是一個 C 的數據結構，用於表示一個你想在一個對象上執行的 Objective-C 方法。在 runtime 中的定義像這樣…

typedef struct objc_selector *SEL;
像這樣使用…

SEL aSel = @selector(movieTitle);
Message（消息）

[target getMovieTitleForObject:obj];
消息是方括號 ‘[]’ 中的那部分，由你要向其發送消息的對象（target），你想要在上面執行的方法（method）還有你發送的參數（arguments）組成。 Objective-C 的消息和 C 函數調用是不同的。事實上，你向一個對象發送消息並不意味着它會執行它。Object（對象）會檢查消息的發送者，基於這點再決定是執行一個不同的方法還是轉發消息到另一個目標對象上。Class 如果你查看一個類的runtime信息，你會看到這個…

typedef struct objc_class *Class;
typedef struct objc_object {
Class isa;
} *id;
這裏有幾個事情。我們有一個 Objective-C 類的結構體和一個對象的結構體。objc_object 只有一個指向類的 isa 指針，就是我們說的術語 “isa pointer”（isa 指針）。這個 isa 指針是當你向對象發送消息時，Objective-C Runtime 檢查一個對象並且查看它的類是什麼然後開始查看它是否響應這些 selectors 所需要的一切。最後我麼看到了 id 指針。默認情況下 id 指針除了告訴我們它們是 Objective-C 對象外沒有其他用了。當你有一個 id 指針，然後你就可以問這個對象是什麼類的，看看它是否響應一個方法，等等，然後你就可以在知道這個指針指向的是什麼對象後執行更多的操作了。你可以在 LLVM/Clang 的文檔中的 Block 中看到

struct Block_literal_1 {
void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
int flags;
int reserved;
void (invoke)(void , …);
struct Block_descriptor_1 {
unsigned long int reserved; // NULL
unsigned long int size; // sizeof(struct Block_literal_1)
// optional helper functions
void (*copy_helper)(void *dst, void *src);
void (*dispose_helper)(void *src);
} *descriptor;
// imported variables
};
Blocks 被設計爲兼容 Objective-C 的 runtime，所以他們被作爲對象對待，因此他們可以響應消息，比如 -retain，-release，-copy ，等等。IMP（方法實現 Method Implementations）

1
typedef id (*IMP)(id self,SEL _cmd,…);
IMP 是指向方法實現的函數指針，由編譯器爲你生成。如果你新接觸 Objective-C 你現在不需要直接接觸這些，但是我們將會看到，Objective-C runtime 將如何調用你的方法的。Objective-C Classes（Objective-C 類）那麼什麼是 Objective-C 類？在 Objective-C 中的一個類實現看起來像這樣：

@interface MyClass : NSObject {
// vars
NSInteger counter;
}
// methods
-(void)doFoo;
@end

但是 runtime 不只要追蹤這些

if !OBJC2

Class super_class                        OBJC2_UNAVAILABLE;
const char *name                         OBJC2_UNAVAILABLE;
long version                             OBJC2_UNAVAILABLE;
long info                                OBJC2_UNAVAILABLE;
long instance_size                       OBJC2_UNAVAILABLE;    
struct objc_ivar_list *ivars             OBJC2_UNAVAILABLE;    
struct objc_method_list **methodLists    OBJC2_UNAVAILABLE;    
struct objc_cache *cache                 OBJC2_UNAVAILABLE;    
struct objc_protocol_*protocols          OBJC2_UNAVAILABLE;

endif

我們可以看到，一個類有其父類的引用，它的名字，實例變量，方法，緩存還有它遵循的協議。runtime 在響應類或實例的方法時需要這些信息。

那麼 Class 定義的是對象還是對象本身？它是如何實現的（譯註：讀者需要區分 Class 和 class 是不同的，正如 Nil 和 nil 的用途是不同的）

是的，之前我說過 Objective-C 類也是對象，runtime 通過創建 Meta Classes 來處理這些。當你發送一個消息像這樣 [NSObject alloc] 你正在向類對象發送一個消息，這個類對象需要是 MetaClass 的實例，MetaClass 也是 root meta class 的實例。當你說繼承自 NSObject 時，你的類指向 NSObject 作爲自己的 superclass。然而，所有的 meta class 指向 root metaclass 作爲自己的 superclass。所有的 meta class 只是簡單的有一個自己響應的方法列表。所以當你向一個類對象發送消息如 [NSObject alloc]，然後實際上 objc_msgSend() 會檢查 meta class 看看它是否響應這個方法，如果他找到了一個方法，就在這個 Class 對象上執行（譯註：class 是一個實例對象的類型，Class 是一個類（class）的類型。對於完全的 OO 來說，類也是個對象，類是類類型(MetaClass)的實例，所以類的類型描述就是 meta class）。

爲什麼我們繼承自蘋果的類

從你開始 Cocoa 開發時，那些教程就說如繼承自 NSObject 然後開始寫一些代碼，你享受了很多繼承自蘋果的類所帶來的便利。有一件事你從未意識到的是你的對象被設置爲使用 Objective-C 的 runtime。當我們爲我們的類的一個實例分配了內存，像這樣…

1
MyObject *object = [[MyObject alloc] init];
最先執行的消息是 +alloc。如果你查看下文檔，它說“新的實例對象的 isa 實例變量被初始化爲指向一個數據結構，那個數據結構描述了這個類；其他的實例變量被初始化爲 0。”所以繼承自蘋果的類不僅僅是繼承了一些重要的屬性，也繼承了能在內存中輕鬆分配內存的能力和在內存中創建滿足 runtime 期望的對象結構（設置 isa 指針指向我們的類）。

那麼 Class Cache 是什麼？（objc_cache *cache）

當 Objective-C runtime 沿着一個對象的 isa 指針檢查時，它會發現一個對象實現了許多的方法。然而你可能只調用其中一小部分的方法，也沒有意義每次檢查時搜索這個類的分發表（dispatch table）中的所有 selector。所以這個類實現了一個緩存，當你搜索一個類的分發表，並找到合適的 selector 後，就會把它放進緩存中。所以當 objc_msgSend() 在一個類中查找 selector 時會先查找類緩存。有個理論是，當你在一個類上調用了一個消息，你很可能之後還會調用它。所以如果我們考慮到這點，就意味着當我們有個子類繼承自 NSObject 叫做 MyObject 並且運行了以下的代碼

MyObject *obj = [[MyObject alloc] init];

@implementation MyObject
- (id)init {
if(self = [super init]) {
[self setVarA:@”blah”];
}
return self;
}
@end
發生了以下的事：

(1) [MyObject alloc] 首先被執行。MyObject 沒有實現 alloc 方法，所以我們不能在這個類中找到 +alloc 方法，然後沿着 superclass 指針會指向 NSObject。

(2) 我們詢問 NSObject 是否響應 +alloc 方法，它可以。+alloc 檢查消息的接收者類，是 MyObject，然後分配一塊和我們的類同樣大小的內存空間，並初始化它的 isa 指針指向 MyObject 類，我們現在有了一個實例對象，最終把類對象的 +alloc 方法加入 NSObject 的類緩存（class cache）中（lastly we put +alloc in NSObject’s class cache for the class object ）。

(3) 到現在爲止，我們發送了一個類消息，但是現在我們發送一個實例消息，只是簡單的調用 -init 或者我們設計的初始化方法。當然，我們的類會響應這個方法，所以 -(id)init 加入到緩存中。（譯註：要是 MyObject 實現了 init 方法，就會把 init 方法加入到 MyObject 的 class cache 中，要是沒有實現，只是因爲繼承纔有了這個方法，init 方法還是會加入到 NSObject 的 class cache 中）。

(4) 然後 self = [super init] 被調用。super 是個 magic keyword，指向對象的父類，所以我們得到了 NSObject 並調用它的的 init 方法。這樣可以確保 OOP（面相對象編程）的繼承功能正常，這個方法可以正確的初始化父類的變量，之後你（在子類中）可以初始化自己的變量，如果需要可以覆蓋父類的方法。在 NSObject 的例子中，沒什麼重要的要做，但並不總是這樣。有時要做些重要的初始化。比如…

import

@interface MyObject : NSObject {
NSString *aString;
}
@property(retain) NSString *aString;

@end

@implementation MyObject

-(id)init
{
if (self = [super init]) {
[self setAString:nil];
}
return self;
}

@synthesize aString;

@end

int main (int argc, const char * argv[])
{
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

id obj1 = [NSMutableArray alloc]; 
id obj2 = [[NSMutableArray alloc] init];   
id obj3 = [NSArray alloc]; 
id obj4 = [[NSArray alloc] initWithObjects:@"Hello",nil];

NSLog(@"obj1 class is %@",NSStringFromClass([obj1 class]));
NSLog(@"obj2 class is %@",NSStringFromClass([obj2 class]));
NSLog(@"obj3 class is %@",NSStringFromClass([obj3 class]));
NSLog(@"obj4 class is %@",NSStringFromClass([obj4 class]));

id obj5 = [MyObject alloc]; 
id obj6 = [[MyObject alloc] init];   

NSLog(@"obj5 class is %@",NSStringFromClass([obj5 class]));    
NSLog(@"obj6 class is %@",NSStringFromClass([obj6 class]));   

[pool drain];
return 0;

}
現在如果你新接觸 Cocoa ，我讓你猜會會輸出什麼，你可能會說

NSMutableArray
NSMutableArray
NSArray
NSArray
MyObject
MyObject
但是，實際上是

obj1 class is __NSPlaceholderArray
obj2 class is NSCFArray
obj3 class is __NSPlaceholderArray
obj4 class is NSCFArray
obj5 class is MyObject
obj6 class is MyObject
這是因爲在 Objective-C 中 +alloc 方法可能會返回某個類的對象，然後在 -init 中返回另一個類的對象。
（譯註：感興趣的同學可以看下這兩篇文章：Class Clusters, Make Your Own Abstract Factory Class Cluster in Objective-C, 第二篇文章需要自備小梯子。)

那麼在 objc_msgSend 中發生了什麼？

事實上在 objc_msgSend() 中發生了許多事兒。假設我們有這樣的代碼…

1
[self printMessageWithString:@”Hello World!”];
它實際上會被編譯器翻譯爲…

1
objc_msgSend(self,@selector(printMessageWithString:),@”Hello World!”);
我們沿着目標對象的 isa 指針查找，看看是否這個對象響應 @selector(printMessageWithString:) selector。假設我們在類的分發表或者緩存中找到了這個 selector，我們沿着函數指針並且執行它。這樣 objcmsgSend() 就永遠不會返回，它開始執行，然後沿着指向方法的指針，然後你的方法返回，這樣看起來 objcmsgSend() 方法返回了。Bill Bumgarner 比我講了更多 objc_msgSend() 的細節（部分1，部分2 和部分3）。

概括下他說的，並且你已經看過了 Objective-C 的 runtime 代碼…

檢查忽略的 Selector 和短路（Short Circut）—— 顯然，如果我們運行在垃圾回收機制下，我們可以忽略調用 -retain, -release, 等等。

檢查 nil 對象（target）。和其他的語言不一樣的是，在 Objective-C 中向 nil 發送消息是完全合法的，並且有些原因下你會願意這麼做的。假設我們有個非 nil 的對象，然後我們繼續…

然後我們需要在這個類上找到 IMP，所以我們先從 class cache 中找起，如果找到了就沿着指針跳到這個函數。

如果沒有在緩存中找到 IMP，然後去查找類的分發表，如果找到了，就沿着指針跳到這個函數。

如果 IMP 沒有在緩存和類的分發表中找到，然後我們跳到轉發機制。這意味着最終你的代碼被編譯器轉換爲 C 函數。你寫的方法會像這樣…

1
-(int)doComputeWithNum:(int)aNum
會被翻譯爲…

1
int aClass_doComputeWithNum(aClass *self,SEL _cmd,int aNum)
Objective-C Runtime 通過調用（invoking）指向這些方法的函數指針調用你的方法（call your methods）。現在，我要說的是，你不能直接調用這些被翻譯的方法，但是 Cocoa 框架提供了獲得函數指針的方法…

//declare C function pointer
int (computeNum *)(id,SEL,int);

//methodForSelector is COCOA & not ObjC Runtime
//gets the same function pointer objc_msgSend gets
computeNum = (int (*)(id,SEL,int))[target methodForSelector:@selector( doComputeWithNum:)];

//execute the C function pointer returned by the runtime
computeNum(obj,@selector(doComputeWithNum:),aNum);
通過這種方法，你可以直接訪問這個函數，並且可以在運行時直接調用，甚至可以使用這個避開 runtime 的動態特性，如果你絕對需要確保一個方法被執行。Objective-C 就是用這種途徑去調用你的方法的，但是使用的是 objc_msgSend()。

Objective-C 消息轉發

在 Objective-C 中向一個不知道如何響應這個方法的對象發送消息是完全合法的（甚至可能是一種潛在的設計決定）。蘋果的文檔中給出的一個原因是模擬多繼承，Objective-C 不是原生支持的，或者你可能只是想抽象你的設計並且隱藏幕後處理這些消息的其他對象/類。這一點是 runtime 非常需要的。它是這樣做的 1. Runtime 檢查了你的類和所有父類的 class cache 和分發表，但是沒找到指定的方法。2. Objective_C 的 Runtime 會在你的類上調用 + (BOOL) resolveInstanceMethod:(SEL)aSEL。這就給了你一個機會去提供一個方法實現並且告訴 runtime 你已經解析了這個方法，如果它開始查找，這回就會找到這個方法。你可以像這樣實現…定義一個函數…

void fooMethod(id obj, SEL _cmd)
{
NSLog(@”Doing Foo”);
}
然後你可以像這樣使用 class_addMethod() 解析它…

+(BOOL)resolveInstanceMethod:(SEL)aSEL
{
if(aSEL == @selector(doFoo:))
{
class_addMethod([self class],aSEL,(IMP)fooMethod,”v@:”);
return YES;
}
return [super resolveInstanceMethod];
}
在 class_addMethod() 最後一部分的 “v@:” 是方法的返回和參數類型。你可以在 Runtime Guide 的 Type Encoding 章節看到完整介紹。 3. Runtime 然後調用 – (id)forwardingTargetForSelector:(SEL)aSelector。這樣做是爲了給你一次機會（因爲我們不能解析這個方法（參見上面的 #2））引導 Objective-C runtime 到另一個可以響應這個消息的對象上，在花費昂貴的處理過程調用 – (void)forwardInvocation:(NSInvocation *)anInvocation 之前調用這個方法也是更好的。你可以像這樣實現

(id)forwardingTargetForSelector:(SEL)aSelector
{
if(aSelector == @selector(mysteriousMethod:))
{
return alternateObject;
}
return [super forwardingTargetForSelector:aSelector];
}
顯然你不想從這個方法直接返回 self，否則可能會產生一個死循環。 4. Runtime 最後一次會嘗試在目標對象上調用 – (void)forwardInvocation:(NSInvocation *)anInvocation。如果你從沒看過 NSInvocation，它是 Objective-C 消息的對象形式。一旦你有了一個 NSInvocation 你可以改變這個消息的一切，包括目標對象，selector 和參數。所以你可以這樣做…

-(void)forwardInvocation:(NSInvocation *)invocation
{
SEL invSEL = invocation.selector;
if([altObject respondsToSelector:invSEL]) {
[invocation invokeWithTarget:altObject];
} else {
[self doesNotRecognizeSelector:invSEL];
}
}
如果你繼承自 NSObject，默認它的 – (void)forwardInvocation:(NSInvocation *)anInvocation 實現只是簡單的調用 -doesNotRecognizeSelector:，你可以在最後一次機會里覆蓋這個方法去做一些事情。（譯註：對這塊內容有興趣的同學可以參見：http://www.cnblogs.com/biosli/p/NSObjectinherit2.html）

Non Fragile ivars（Modern Runtime）（非脆弱的 ivar）

我們最近在 Modern Runtime 裏得到的是 Non Fragile ivars 的概念。當編譯你的類時，編譯器生成了一個 ivar 佈局，顯示了在你的類中從哪可以訪問你的 ivars，獲取指向你的對象的指針，查看 ivar 與對象起始字節的偏移關係，和獲取讀入的變量類型的總共字節大小等一些底層的細節。所以你的 ivar 佈局可能看起來像這樣，左側的數字是字節偏移量。

2014031602.png

我們有了 NSObject 的 ivar 佈局，然後我們繼承自 NSObject 去擴展它並且添加了我們自己的 ivars。在蘋果發佈更新前這都工作的很好，但是 Mac OS X 10.6 發佈後，就成了這樣

2014031603.png

你的自定義對象被剔除了因爲我們有了一個重疊的父類。唯一可以防止這個的辦法是如果蘋果堅持之前的佈局，如果他們這麼做了，那麼他們的框架就不能改進，因爲他們的 ivar 佈局被凍住了。在 fragile ivar 下你不得不重新編譯你繼承自蘋果類的類來恢復兼容性。所以在非 fragile ivar 時，會發生生麼？

2014031604.png

使用非 fragile ivars 時，編譯器生成和 fragile ivars 相同的 ivar 佈局。然而當 runtime 檢測到一個重疊的超類時，它調整你在這個類中新增的 ivar 的偏移量，這樣在子類中新增加的那部分就顯示出來了。

Objective-C 關聯對象

最近在 Mac OS X 10.6 雪豹中新引入了關聯引用。Objective-C 不能動態的添加一些屬性到對象上，和其他的一些原生支持這點的語言不一樣。所以之前你都不得不努力爲未來要增加的變量預留好空間。在 Mac OS X 10.6 中，Objective-C 的 Runtime 已經原生的支持這個功能了。如果我們想向一個已有的類添加變量，看起來像這樣…

import //Cocoa

include //objc runtime api’s

@interface NSView (CustomAdditions)
@property(retain) NSImage *customImage;
@end

@implementation NSView (CustomAdditions)

static char img_key; //has a unique address (identifier)

(NSImage *)customImage
{
return objc_getAssociatedObject(self,&img_key);
}
(void)setCustomImage:(NSImage *)image
{
objc_setAssociatedObject(self, &img_key,image, OBJC_ASSOCIATION_RETAIN);
}

@end

objc_setAssociatedObject() 的選項，你可以在 runtime.h 文件中找到。

/* Associated Object support. */

/* objc_setAssociatedObject() options */
enum {
OBJC_ASSOCIATION_ASSIGN = 0,
OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,
OBJC_ASSOCIATION_COPY_NONATOMIC = 3,
OBJC_ASSOCIATION_RETAIN = 01401,
OBJC_ASSOCIATION_COPY = 01403
};
這些和 @property 語法中的選項意思一樣。

混和的 vTable Dispatch

如果你看過 modern runtime 的代碼，你會發現這個（在 objc-runtime-new.m 中）

/*************************************************************
* vtable dispatch
*
* Every class gets a vtable pointer. The vtable is an array of IMPs.
* The selectors represented in the vtable are the same for all classes
* (i.e. no class has a bigger or smaller vtable).
* Each vtable index has an associated trampoline which dispatches to
* the IMP at that index for the receiver class’s vtable (after
* checking for NULL). Dispatch fixup uses these trampolines instead
* of objc_msgSend.
* Fragility: The vtable size and list of selectors is chosen at launch
* time. No compiler-generated code depends on any particular vtable
* configuration, or even the use of vtable dispatch at all.
* Memory size: If a class’s vtable is identical to its superclass’s
* (i.e. the class overrides none of the vtable selectors), then
* the class points directly to its superclass’s vtable. This means
* selectors to be included in the vtable should be chosen so they are
* (1) frequently called, but (2) not too frequently overridden. In
* particular, -dealloc is a bad choice.
* Forwarding: If a class doesn’t implement some vtable selector, that
* selector’s IMP is set to objc_msgSend in that class’s vtable.
* +initialize: Each class keeps the default vtable (which always
* redirects to objc_msgSend) until its +initialize is completed.
* Otherwise, the first message to a class could be a vtable dispatch,
* and the vtable trampoline doesn’t include +initialize checking.
* Changes: Categories, addMethod, and setImplementation all force vtable
* reconstruction for the class and all of its subclasses, if the
* vtable selectors are affected.
************************************************************/
背後的思想是，runtime 嘗試在這個 vtable 中存儲最近被調用的 selectors，這樣就可以提升你的應用的速度，因爲它使用了比 objc_msgSend 更少的指令（fewer instructions）。vtable 中保存 16 個全局最經常調用的 selectors，事實上順着代碼往下看你可以發現垃圾回收和非垃圾回收類型程序的默認 selectors ：

static const char * const defaultVtable[] = {
“allocWithZone:”,
“alloc”,
“class”,
“self”,
“isKindOfClass:”,
“respondsToSelector:”,
“isFlipped”,
“length”,
“objectForKey:”,
“count”,
“objectAtIndex:”,
“isEqualToString:”,
“isEqual:”,
“retain”,
“release”,
“autorelease”,
};
static const char * const defaultVtableGC[] = {
“allocWithZone:”,
“alloc”,
“class”,
“self”,
“isKindOfClass:”,
“respondsToSelector:”,
“isFlipped”,
“length”,
“objectForKey:”,
“count”,
“objectAtIndex:”,
“isEqualToString:”,
“isEqual:”,
“hash”,
“addObject:”,
“countByEnumeratingWithState:objects:count:”,
};
你可以在調試時從堆棧追蹤裏找到其中的method，可以像objc_msgSend()一樣將它們用於調試。

Objective-C Runtime深入理解（三）

include

if !OBJC2

endif

import

import //Cocoa

include //objc runtime api’s

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

linux安裝cuda和cudnn

Mellanox網卡開啓SR-IOV

模擬手機設備：使用 Playwright 實現移動端自動化測試

HTML 00 Tutorial

全面系統的AI學習路徑，幫助普通人也能玩轉AI

從零開始：使用 Playwright 腳本錄製實現自動化測試

uni-app實現上拉加載

Java IDE NetBeats 使用詳解

Objective-C Runtime深入理解（三）

Objective-C Runtime深入理解（二）

Objective-C Runtime深入理解（一）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結