讀了N 遍南峰子老師的博客，對老師的Runtime的講解雖不能說百分之百的聊熟于心，但也能做到熟練掌握，重新記錄下來，留給以后的自己翻看查閱。
記錄分六個部分：
- Objective-C Runtime 之一：類與對象。 點擊查看
- Objective-C Runtime 之二：成員變量與屬性。 點擊查看
- Objective-C Runtime 之三：方法與消息。 點擊查看
- Objective-C Runtime 之四：Method Swizzling。 點擊查看
- Objective-C Runtime 之五：協(xié)議與分類。 點擊查看
- Objective-C Runtime 之六：拾遺。 點擊查看
本篇文章記錄第一部分：
一、 Objective-C 特性：
Objective-C語言是一門動態(tài)語言，它將很多靜態(tài)語言在編譯和鏈接時期做的事放到了運行時來處理。這種動態(tài)語言的優(yōu)勢在于：我們寫代碼時更具靈活性，如我們可以把消息轉(zhuǎn)發(fā)給我們想要的對象，或者隨意交換一個方法的實現(xiàn)等。
這種特性意味著Objective-C不僅需要一個編譯器，還需要一個運行時系統(tǒng)來執(zhí)行編譯的代碼。對于Objective-C來說，這個運行時系統(tǒng)就像一個操作系統(tǒng)一樣：它讓所有的工作可以正常的運行。這個運行時系統(tǒng)即Objc Runtime。Objc Runtime其實是一個Runtime庫，它基本上是用C和匯編寫的，這個庫使得C語言有了面向?qū)ο蟮哪芰Α?/p>
二、 Runtime 做了什么：
- 封裝（這是Runtime發(fā)揮作用的前提）
- 對象：用C語言的結(jié)構(gòu)體表示
- 方法：用C函數(shù)實現(xiàn)
- 確定方法的執(zhí)行流程
- 當程序執(zhí)行[object doSomething]時，會向消息接收者(object)發(fā)送一條消息(doSomething)，runtime會根據(jù)消息接收者是否能響應該消息而做出不同的反應。
三、 類與對象基礎數(shù)據(jù)結(jié)構(gòu)：
Class
Objective-C類是由Class類型來表示的，我們剛才說了，Runtime做了封裝，將類封裝成結(jié)構(gòu)體 objc_class ，而我們平時所用到的Class其實就是指向結(jié)構(gòu)體的一個指針。結(jié)構(gòu)體的定義如下：
指針：
typedef struct objc_class *Class;
結(jié)構(gòu)體：查看objc/runtime.h中objc_class結(jié)構(gòu)體的定義如下
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE; // 父類
const char *name OBJC2_UNAVAILABLE; // 類名
long version OBJC2_UNAVAILABLE; // 類的版本信息，默認為0
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_list *protocols OBJC2_UNAVAILABLE; // 協(xié)議鏈表
#endif
} OBJC2_UNAVAILABLE;
在這里對上述的部分字段進行一下說明：
- isa：需要注意的是在Objective-C中，所有的類自身也是一個對象，這個對象的Class里面也有一個isa指針，它指向metaClass(元類)，我們會在后面介紹它。
super_class：指向該類的父類，如果該類已經(jīng)是最頂層的根類(如NSObject或NSProxy)，則super_class為NULL。 - cache：用于緩存最近使用的方法。一個接收者對象接收到一個消息時，它會根據(jù)isa指針去查找能夠響應這個消息的對象。在實際使用中，這個對象只有一部分方法是常用的，很多方法其實很少用或者根本用不上。這種情況下，如果每次消息來時，我們都是methodLists中遍歷一遍，性能勢必很差。這時，cache就派上用場了。在我們每次調(diào)用過一個方法后，這個方法就會被緩存到cache列表中，下次調(diào)用的時候runtime就會優(yōu)先去cache中查找，如果cache沒有，才去methodLists中查找方法。這樣，對于那些經(jīng)常用到的方法的調(diào)用，但提高了調(diào)用的效率。
- version：我們可以使用這個字段來提供類的版本信息。這對于對象的序列化非常有用，它可是讓我們識別出不同類定義版本中實例變量布局的改變。
針對cache，我們用下面例子來說明其執(zhí)行過程：
NSArray *array = [[NSArray alloc] init];
其流程是：
1. `[NSArray alloc]`先被執(zhí)行。因為NSArray沒有`+alloc`方法，于是去父類NSObject去查找。
2. 檢測NSObject是否響應`+alloc`方法，發(fā)現(xiàn)響應，于是檢測NSArray類，并根據(jù)其所需的內(nèi)存空間大小開始分配內(nèi)存空間( 根據(jù) instance_size 確定大小)，然后把`isa`指針指向NSArray類（ 生成對象 確定 isa 所指的類 對象接收消息時候會用到 ）。同時，`+alloc`也被加進cache列表里面。
3. 接著，執(zhí)行`-init`方法，如果NSArray響應該方法，則直接將其加入`cache`；如果不響應，則去父類查找。
4. 在后期的操作中，如果再以`[[NSArray alloc] init]`這種方式來創(chuàng)建數(shù)組，則會直接從cache中取出相應的方法，直接調(diào)用。
Object
既然類 Class 是指向類結(jié)構(gòu)體的指針，正常推理 Object 也是這個一個指針，指向類實例結(jié)構(gòu)體。不過我們不用 Object 類表示 ，而是用 id 來表示。
指針：
typedef struct objc_object *id;
結(jié)構(gòu)體：
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
可以看到，這個結(jié)構(gòu)體只有一個字體，即指向其類的isa指針。這樣，當我們向一個Objective-C對象發(fā)送消息時，運行時庫會根據(jù)實例對象的isa指針找到這個實例對象所屬的類。Runtime庫會在類的方法列表及父類的方法列表中去尋找與消息對應的selector指向的方法。找到后即運行這個方法。
當創(chuàng)建一個特定類的實例對象時，分配的內(nèi)存包含一個objc_object數(shù)據(jù)結(jié)構(gòu)，然后是類的實例變量的數(shù)據(jù)。NSObject類的alloc和allocWithZone:方法使用函數(shù)class_createInstance來創(chuàng)建objc_object數(shù)據(jù)結(jié)構(gòu)。
objc_cache
上面提到了objc_class結(jié)構(gòu)體中的cache字段，該字段也是指向結(jié)構(gòu)體的一個指針，它用于緩存調(diào)用過的方法。其定義如下：
struct objc_cache {
unsigned int mask /* total = mask + 1 */ OBJC2_UNAVAILABLE;
unsigned int occupied OBJC2_UNAVAILABLE;
Method buckets[1] OBJC2_UNAVAILABLE;
};
該結(jié)構(gòu)體的字段描述如下：
1 、mask：一個整數(shù)，指定分配的緩存bucket的總數(shù)。在方法查找過程中，Objective-C runtime使用這個字段來確定開始線性查找數(shù)組的索引位置。指向方法selector的指針與該字段做一個AND位操作(index = (mask & selector))。這可以作為一個簡單的hash散列算法。
2、occupied：一個整數(shù)，指定實際占用的緩存bucket的總數(shù)。
3、buckets：指向Method數(shù)據(jù)結(jié)構(gòu)指針的數(shù)組。這個數(shù)組可能包含不超過mask+1個元素。需要注意的是，指針可能是NULL，表示這個緩存bucket沒有被占用，另外被占用的bucket可能是不連續(xù)的。這個數(shù)組可能會隨著時間而增長。
元類(Meta Class)
在上面我們提到，所有的類自身也是一個對象，我們可以向這個對象發(fā)送消息(即調(diào)用類方法)。如：
NSArray *array = [NSArray array];
這個例子中，+array消息發(fā)送給了NSArray類，而這個NSArray也是一個對象。既然是一個對象，那么肯定能找到這個對象所屬的類，怎么找？通過什么找？這就是要借用 isa 指針了。找到這個類以后，這個類中還要包含一個指向方法列表的指針。這就引出了 meta-class 的概念
meta-class 是一個類對象的類
重點來了：
- 向類的例化對象發(fā)送消息，runtime會在這個對象所屬的類的方法列表中查找方法
- 向類發(fā)送消息時，會在該類所屬的元類中的方法列表中查找
meta-class之所以重要，是因為它存儲著一個類的所有類方法。每個類都會有一個單獨的meta-class，因為每個類的類方法基本不可能完全相同。
再深入一下，meta-class也是一個類，也可以向它發(fā)送一個消息，那么它的isa又是指向什么呢？為了不讓這種結(jié)構(gòu)無限延伸下去，Objective-C的設計者讓所有的meta-class的isa指向基類的meta-class，以此作為它們的所屬類。即，任何NSObject繼承體系下的meta-class都使用NSObject的meta-class作為自己的所屬類，而基類的meta-class的isa指針是指向它自己。這樣就形成了一個完美的閉環(huán)。
通過上面的描述，再加上對objc_class結(jié)構(gòu)體中super_class指針的分析，我們就可以描繪出類及相應meta-class類的一個繼承體系了，如下圖所示：
元類也是有繼承關(guān)系的。
怎么樣才能用代碼直觀的看出來元類的繼承體系呢？可以通過下面的例子看出來，例子中可能有沒有涉及的東西，沒關(guān)系，看懂大概就行：
void TestMetaClass(id self, SEL _cmd) {
NSLog(@"This objcet is %p", self);
NSLog(@"Class is %@, super class is %@", [self class], [self superclass]);
Class currentClass = [self class];
for (int i = 0; i < 4; i++) {
NSLog(@"Following the isa pointer %d times gives %p", i, currentClass);
currentClass = objc_getClass((__bridge void *)currentClass);
}
NSLog(@"NSObject's class is %p", [NSObject class]);
NSLog(@"NSObject's meta class is %p", objc_getClass((__bridge void *)[NSObject class]));
}
#pragma mark -
@implementation Test
- (void)ex_registerClassPair {
Class newClass = objc_allocateClassPair([NSError class], "TestClass", 0);
class_addMethod(newClass, @selector(testMetaClass), (IMP)TestMetaClass, "v@:");
objc_registerClassPair(newClass);
id instance = [[newClass alloc] initWithDomain:@"some domain" code:0 userInfo:nil];
[instance performSelector:@selector(testMetaClass)];
}
@end
這個例子是在運行時創(chuàng)建了一個NSError的子類TestClass，然后為這個子類添加一個方法testMetaClass，這個方法的實現(xiàn)是TestMetaClass函數(shù)。
運行后，打印結(jié)果是
2017-10-20 22:57:07.352 mountain[1303:41490] This objcet is 0x7a6e22b0
2017-10-20 22:57:07.353 mountain[1303:41490] Class is TestStringClass, super class is NSError
2017-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 0 times gives 0x7a6e21b0
2017-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 1 times gives 0x0
2017-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 2 times gives 0x0
2017-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 3 times gives 0x0
2017-10-20 22:57:07.353 mountain[1303:41490] NSObject's class is 0xe10000
2017-10-20 22:57:07.354 mountain[1303:41490] NSObject's meta class is 0x0
我們在for循環(huán)中，我們通過 objc_getClass 來獲取對象的 isa ，并將其打印出來，依此一直回溯到 NSObject 的 meta-class 。分析打印結(jié)果，可以看到最后指針指向的地址是 0x0，即 NSObject 的 meta-class 的類地址。
這里需要注意的是：我們在一個類對象調(diào)用class方法是無法獲取meta-class，它只是返回類而已。
四、 類與對象的操作函數(shù)：
runtime提供了大量的函數(shù)來操作類與對象。類的操作方法大部分是以class_為前綴的，而對象的操作方法大部分是以objc_或object_為前綴。下面我們將根據(jù)這些方法的用途來分類討論這些方法的使用。
類操作函數(shù)
此處我們在來看一下objc_class 的定義：
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE; // 父類
const char *name OBJC2_UNAVAILABLE; // 類名
long version OBJC2_UNAVAILABLE; // 類的版本信息，默認為0
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_list *protocols OBJC2_UNAVAILABLE; // 協(xié)議鏈表
#endif
} OBJC2_UNAVAILABLE;
類名
1 // 獲取類的類名
2 const char * class_getName ( Class cls );
- 對于class_getName函數(shù)，如果傳入的cls為Nil，則返回一個字字符串
父類和元類
1 // 獲取類的父類
2 Class class_getSuperclass ( Class cls );
3 // 判斷給定的Class是否是一個元類
4 BOOL class_isMetaClass ( Class cls );
class_getSuperclass函數(shù)，當cls為Nil或者cls為根類時，返回Nil。不過通常我們可以使用NSObject類的superclass方法來達到同樣的目的。
class_isMetaClass函數(shù)，如果是cls是元類，則返回YES；如果否或者傳入的cls為Nil，則返回NO。
實例變量大小(instance_size)
1 // 獲取實例大小
2 size_t class_getInstanceSize ( Class cls );
成員變量(ivars)及屬性
在objc_class中，所有的成員變量、屬性的信息是放在鏈表ivars中的。ivars是一個數(shù)組，數(shù)組中每個元素是指向Ivar(變量信息)的指針。runtime提供了豐富的函數(shù)來操作這一字段。大體上可以分為以下幾類：
1.成員變量操作函數(shù)，主要包含以下函數(shù)：
// 獲取類中指定名稱實例成員變量的信息
Ivar class_getInstanceVariable ( Class cls, const char *name );
// 獲取類成員變量的信息
- Ivar class_getClassVariable ( Class cls, const char *name );
// 添加成員變量
BOOL class_addIvar ( Class cls, const char *name, size_t size, uint8_t alignment, const char *types );
// 獲取整個成員變量列表
Ivar * class_copyIvarList ( Class cls, unsigned int *outCount );
class_getInstanceVariable 函數(shù)，它返回一個指向包含name指定的成員變量信息的objc_ivar結(jié)構(gòu)體的指針(Ivar)。
class_getClassVariable函數(shù)，目前沒有找到關(guān)于Objective-C中類變量的信息，一般認為Objective-C不支持類變量。注意，返回的列表不包含父類的成員變量和屬性。
Objective-C不支持往已存在的類中添加實例變量，因此不管是系統(tǒng)庫提供的提供的類，還是我們自定義的類，都無法動態(tài)添加成員變量。但如果我們通過運行時來創(chuàng)建一個類的話，又應該如何給它添加成員變量呢？這時我們就可以使用class_addIvar函數(shù)了。不過需要注意的是，這個方法只能在objc_allocateClassPair函數(shù)與objc_registerClassPair之間調(diào)用。另外，這個類也不能是元類。成員變量的按字節(jié)最小對齊量是1<<alignment。這取決于ivar的類型和機器的架構(gòu)。如果變量的類型是指針類型，則傳遞log2(sizeof(pointer_type))。
class_copyIvarList函數(shù)，它返回一個指向成員變量信息的數(shù)組，數(shù)組中每個元素是指向該成員變量信息的objc_ivar結(jié)構(gòu)體的指針。這個數(shù)組不包含在父類中聲明的變量。outCount指針返回數(shù)組的大小。需要注意的是，我們必須使用free()來釋放這個數(shù)組。
2.屬性操作函數(shù)，主要包含以下函數(shù)
// 獲取指定的屬性
objc_property_t class_getProperty ( Class cls, const char *name );
// 獲取屬性列表
objc_property_t * class_copyPropertyList ( Class cls, unsigned int *outCount );
// 為類添加屬性
BOOL class_addProperty ( Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount );
// 替換類的屬性
void class_replaceProperty ( Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount );
這一種方法也是針對ivars來操作，不過只操作那些是屬性的值。我們在后面介紹屬性時會再遇到這些函數(shù)。
3.在MAC OS X系統(tǒng)中，我們可以使用垃圾回收器。runtime提供了幾個函數(shù)來確定一個對象的內(nèi)存區(qū)域是否可以被垃圾回收器掃描，以處理strong/weak引用。這幾個函數(shù)定義如下：
const uint8_t * class_getIvarLayout ( Class cls );
void class_setIvarLayout ( Class cls, const uint8_t *layout );
const uint8_t * class_getWeakIvarLayout ( Class cls );
void class_setWeakIvarLayout ( Class cls, const uint8_t *layout );
但通常情況下，我們不需要去主動調(diào)用這些方法；在調(diào)用objc_registerClassPair時，會生成合理的布局。在此不詳細介紹這些函數(shù)。
方法(methodLists)
// 添加方法
BOOL class_addMethod ( Class cls, SEL name, IMP imp, const char *types );
// 獲取實例方法
Method class_getInstanceMethod ( Class cls, SEL name );
// 獲取類方法
Method class_getClassMethod ( Class cls, SEL name );
// 獲取所有方法的數(shù)組
Method * class_copyMethodList ( Class cls, unsigned int *outCount );
// 替代方法的實現(xiàn)
IMP class_replaceMethod ( Class cls, SEL name, IMP imp, const char *types );
// 返回方法的具體實現(xiàn)
IMP class_getMethodImplementation ( Class cls, SEL name );
IMP class_getMethodImplementation_stret ( Class cls, SEL name );
// 類實例是否響應指定的selector
BOOL class_respondsToSelector ( Class cls, SEL sel );
重點來了：
- class_addMethod (返回BOOL值) 的實現(xiàn)會覆蓋父類的方法，但是但是但是但是不會取代本類中已經(jīng)存在的實現(xiàn)，如果本類中包含一個同名的實現(xiàn)，則函數(shù)會返回NO。這樣的話是不是就不能修改已經(jīng)存在的實現(xiàn)了呢？？？答案是NO?。?！我們可以通過 method_setImplementation 來修改。一個Objective-C方法是一個簡單的C函數(shù)，它至少包含兩個參數(shù)–self和_cmd。所以，我們的實現(xiàn)函數(shù)(IMP參數(shù)指向的函數(shù))至少需要兩個參數(shù)，如下所示：
void myMethodIMP(id self, SEL _cmd)
{
// implementation ....
}
與成員變量不同的是，我們可以為類動態(tài)添加方法，不管這個類是否已存在.
另外，參數(shù)types是一個描述傳遞給方法的參數(shù)類型的字符數(shù)組，這就涉及到類型編碼，我們將在后面介紹。
class_getInstanceMethod、class_getClassMethod函數(shù)，與class_copyMethodList不同的是，這兩個函數(shù)都會去搜索父類的實現(xiàn)。
class_copyMethodList函數(shù)，返回包含所有實例方法的數(shù)組，如果需要獲取類方法，則可以使用class_copyMethodList(object_getClass(cls), &count)(一個類的實例方法是定義在元類里面)。該列表不包含父類實現(xiàn)的方法。outCount參數(shù)返回方法的個數(shù)。在獲取到列表后，我們需要使用free()方法來釋放它。
class_replaceMethod函數(shù)，該函數(shù)的行為可以分為兩種：如果類中不存在name指定的方法，則類似于class_addMethod函數(shù)一樣會添加方法；如果類中已存在name指定的方法，則類似于method_setImplementation一樣替代原方法的實現(xiàn)。
class_getMethodImplementation函數(shù)，該函數(shù)在向類實例發(fā)送消息時會被調(diào)用，并返回一個指向方法實現(xiàn)函數(shù)的指針。這個函數(shù)會比method_getImplementation(class_getInstanceMethod(cls, name))更快。返回的函數(shù)指針可能是一個指向runtime內(nèi)部的函數(shù)，而不一定是方法的實際實現(xiàn)。例如，如果類實例無法響應selector，則返回的函數(shù)指針將是運行時消息轉(zhuǎn)發(fā)機制的一部分。
class_respondsToSelector函數(shù)，我們通常使用NSObject類的respondsToSelector:或instancesRespondToSelector:方法來達到相同目的。
協(xié)議(objc_protocol_list)
// 添加協(xié)議
BOOL class_addProtocol ( Class cls, Protocol *protocol );
// 返回類是否實現(xiàn)指定的協(xié)議
BOOL class_conformsToProtocol ( Class cls, Protocol *protocol );
// 返回類實現(xiàn)的協(xié)議列表
Protocol * class_copyProtocolList ( Class cls, unsigned int *outCount );
class_conformsToProtocol函數(shù)可以使用NSObject類的conformsToProtocol:方法來替代。
class_copyProtocolList函數(shù)返回的是一個數(shù)組，在使用后我們需要使用free()手動釋放。
實例(Example)源碼
上面列舉了大量類操作的函數(shù)，下面我們寫個實例，來看看這些函數(shù)的實例效果：
先來看一下整個項目的結(jié)構(gòu)圖：
兩個類之間是繼承關(guān)系：
===================================================
***
RuntimeViewController 類
// RuntimeViewController.h
#import <UIKit/UIKit.h>
NS_ASSUME_NONNULL_BEGIN
@interface RuntimeViewController : UIViewController
@property (nonatomic, copy) NSArray *array;
@property (nonatomic, copy) NSString *string;
- (void)method1;
- (void)method2;
+ (void)classMethod1;
@end
NS_ASSUME_NONNULL_END
=====================================================
// RuntimeViewController.m
#import "RuntimeViewController.h"
@interface RuntimeViewController (){
NSInteger _instance1;
NSString * _instance2;
}
@property (nonatomic, assign) NSUInteger integer;
- (void)method3WithArg1:(NSInteger)arg1 arg2:(NSString *)arg2;
@end
@implementation RuntimeViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
}
+ (void)classMethod1 {
NSLog(@"類方法 call classMethod1");
}
- (void)method1 {
NSLog(@"實例方法 call method1");
}
- (void)method2 {
NSLog(@"實例方法 call method2");
}
- (void)method3WithArg1:(NSInteger)arg1 arg2:(NSString *)arg2 {
NSLog(@"arg1 : %ld, arg2 : %@", arg1, arg2);
}
@end
===================================================
// SubRuntimeViewController 類
#import "SubRuntimeViewController.h"
#import <objc/runtime.h>
@interface SubRuntimeViewController ()
{
NSArray *subArray;
}
@property (nonatomic, strong) NSString *subString;
@end
@implementation SubRuntimeViewController
- (void)viewDidLoad {
[super viewDidLoad];
NSLog(@"self is : %@", self);
// 類名
NSLog(@"current class name: %s", class_getName([self class]));
NSLog(@"------------------------------------------");
// 父類
NSLog(@"super class name: %s", class_getName(class_getSuperclass(self.class)));
NSLog(@"super class name: %s", class_getName(self.superclass));
// 獲取父類方法有兩種方式 self.superclass 或者 class_getsuperclass(self.class)
NSLog(@"------------------------------------------");
// 是否是元類
NSLog(@"self.class is %@ a meta-class", class_isMetaClass(self.class)? @"": @"not");
NSLog(@"------------------------------------------");
// 獲取當前類的元類
Class meta_class = objc_getMetaClass(object_getClassName(self.class));
NSLog(@"%s's meta-class is %@", object_getClassName(self.class), meta_class);
NSLog(@"------------------------------------------");
// 實例變量大小
NSLog(@"instance size: %zu", class_getInstanceSize(self.class));
NSLog(@"------------------------------------------");
// 成員變量
unsigned int outCount = 0;
// 通過傳遞地址的方式給變量賦值
Ivar *ivars = class_copyIvarList(self.class, &outCount);
for (NSInteger i = 0; i < outCount; i++) {
Ivar ivar = ivars[I];
NSLog(@"instance variable's name: %s at index: %ld", ivar_getName(ivar), (long)i);
}
free(ivars);
Ivar string = class_getInstanceVariable(self.class, "_subString");
if (string != NULL) {
NSLog(@"instace variable %s", ivar_getName(string));
}
// 數(shù)組都要釋放
// 并不會查詢父類
NSLog(@"------------------------------------------");
//屬性操作
objc_property_t *properties = class_copyPropertyList(self.class, &outCount);
for (NSInteger k = 0; k < outCount; k ++) {
objc_property_t property = properties[k];
NSLog(@"property's name: %s", property_getName(property));
}
free(properties);
// 數(shù)組都要釋放
// 并不會查詢父類
NSLog(@"------------------------------------------");
// 方法操作
Method *methods = class_copyMethodList(self.superclass, &outCount);
for (int i = 0; i < outCount; i++) {
Method method = methods[I];
// 此處會報錯 咱沒找到原因
// NSLog(@"method's signature: %@", method_getName(method));
}
free(methods);
Method method1 = class_getInstanceMethod(self.class, @selector(method1));
if (method1 != NULL) {
NSLog(@"method %s", method_getName(method1));
}
Method classMethod = class_getClassMethod(self.class, @selector(classMethod1));
if (classMethod != NULL) {
NSLog(@"class method : %s", method_getName(classMethod));
}
NSLog(@"MyClass is%@ responsd to selector: method3WithArg1:arg2:", class_respondsToSelector(self.class, @selector(method3WithArg1:arg2:)) ? @"" : @" not");
IMP imp = class_getMethodImplementation(self.class, @selector(method1));
imp();
NSLog(@"------------------------------------------");
}
@end
結(jié)果如下圖：
runtime的強大之處在于它能在運行時創(chuàng)建類和對象
動態(tài)創(chuàng)建類
動態(tài)創(chuàng)建類和對象 主要涉及到以下幾個函數(shù)：
// 創(chuàng)建一個新類和元類
Class objc_allocateClassPair ( Class superclass, const char *name, size_t extraBytes );
// 銷毀一個類及其相關(guān)聯(lián)的類
void objc_disposeClassPair ( Class cls );
// 在應用中注冊由objc_allocateClassPair創(chuàng)建的類
void objc_registerClassPair ( Class cls );
- objc_allocateClassPair 函數(shù)：如果我們要創(chuàng)建一個根類，則superclass指定為Nil。extraBytes通常指定為0，該參數(shù)是分配給類和元類對象尾部的索引ivars的字節(jié)數(shù)。
重點來了：
- 為了創(chuàng)建一個新類，我們需要調(diào)用objc_allocateClassPair。然后使用諸如class_addMethod，class_addIvar等函數(shù)來為新創(chuàng)建的類添加方法、實例變量和屬性等。完成這些后，我們需要調(diào)用objc_registerClassPair函數(shù)來注冊類，之后這個新類就可以在程序中使用了。
- 實例方法和實例變量應該添加到類自身上，而類方法應該添加到類的元類上
- objc_disposeClassPair函數(shù)用于銷毀一個類，不過需要注意的是，如果程序運行中還存在類或其子類的實例，則不能調(diào)用針對類調(diào)用該方法
在前面介紹元類時，我們已經(jīng)有接觸到這幾個函數(shù)了，在此我們再舉個實例來看看這幾個函數(shù)的使用。
Class cls = objc_allocateClassPair(MyClass.class, "MySubClass", 0);
class_addMethod(cls, @selector(submethod1), (IMP)imp_submethod1, "v@:");
class_replaceMethod(cls, @selector(method1), (IMP)imp_submethod1, "v@:");
class_addIvar(cls, "_ivar1", sizeof(NSString *), log(sizeof(NSString *)), "i");
objc_property_attribute_t type = {"T", "@\"NSString\""};
objc_property_attribute_t ownership = { "C", "" };
objc_property_attribute_t backingivar = { "V", "_ivar1"};
objc_property_attribute_t attrs[] = {type, ownership, backingivar};
class_addProperty(cls, "property2", attrs, 3);
objc_registerClassPair(cls);
id instance = [[cls alloc] init];
[instance performSelector:@selector(submethod1)];
[instance performSelector:@selector(method1)];
程序的輸出如下：
2017-10-23 11:35:31.006 RuntimeTest[3800:66152] run sub method 1
2017-10-23 11:35:31.006 RuntimeTest[3800:66152] run sub method 1
動態(tài)創(chuàng)建對象
動態(tài)創(chuàng)建對象的函數(shù)如下：
// 創(chuàng)建類實例
id class_createInstance ( Class cls, size_t extraBytes );
// 在指定位置創(chuàng)建類實例
id objc_constructInstance ( Class cls, void *bytes );
// 銷毀類實例
void * objc_destructInstance ( id obj );
- class_createInstance函數(shù)：創(chuàng)建實例時，會在默認的內(nèi)存區(qū)域為類分配內(nèi)存。extraBytes參數(shù)表示分配的額外字節(jié)數(shù)。這些額外的字節(jié)可用于存儲在類定義中所定義的實例變量之外的實例變量。該函數(shù)在ARC環(huán)境下無法使用。
- 調(diào)用class_createInstance的效果與+alloc方法類似。
不過在使用class_createInstance時，我們需要 " 確切的知道" 我們要用它來做什么。在下面的例子中，我們用NSString來測試一下該函數(shù)的實際效果：
id theObject = class_createInstance(NSString.class, sizeof(unsigned));
id str1 = [theObject init];
NSLog(@"%@", [str1 class]);
id str2 = [[NSString alloc] initWithString:@"test"];
NSLog(@"%@", [str2 class]);
輸出結(jié)果是：
2017-10-23 12:46:50.781 RuntimeTest[4039:89088] NSString
2017-10-23 12:46:50.781 RuntimeTest[4039:89088] __NSCFConstantString
- 可以看到，使用class_createInstance函數(shù)獲取的是NSString實例，而不是類簇中的默認占位符類__NSCFConstantString。
- objc_constructInstance函數(shù)：在指定的位置(bytes)創(chuàng)建類實例。
- objc_destructInstance函數(shù)：銷毀一個類的實例，但不會釋放并移除任何與其相關(guān)的引用。
實例操作函數(shù)
實例操作函數(shù)主要是針對我們創(chuàng)建的實例對象的一系列操作函數(shù)，我們可以使用這組函數(shù)來從實例對象中獲取我們想要的一些信息，如實例對象中變量的值。這組函數(shù)可以分為三小類：
1.針對整個對象進行操作的函數(shù)，這類函數(shù)包含
// 返回指定對象的一份拷貝
id object_copy ( id obj, size_t size );
// 釋放指定對象占用的內(nèi)存
id object_dispose ( id obj );
有這樣一種場景，假設我們有類A和類B，且類B是類A的子類。類B通過添加一些額外的屬性來擴展類A?，F(xiàn)在我們創(chuàng)建了一個A類的實例對象，并希望在運行時將這個對象轉(zhuǎn)換為B類的實例對象，這樣可以添加數(shù)據(jù)到B類的屬性中。這種情況下，我們沒有辦法直接轉(zhuǎn)換，因為B類的實例會比A類的實例更大，沒有足夠的空間來放置對象。此時，我們就要以使用以上幾個函數(shù)來處理這種情況，如下代碼所示：
NSObject *a = [[NSObject alloc] init];
id newB = object_copy(a, class_getInstanceSize(MyClass.class));
object_setClass(newB, MyClass.class);
object_dispose(a);
- NSObject 相當于上述提到的A 、MyClass.class 相當于上述提到的B
- object_copy 其實是在copy a 的同時，把所需要的內(nèi)存空間增加了，增加到B類對象所需要的空間
- 通過 object_setClass() 函數(shù)賦值
- 針對對象的 變量進行操作的函數(shù)：
// 修改類實例的實例變量的值
Ivar object_setInstanceVariable ( id obj, const char *name, void *value );
// 獲取對象實例變量的值
Ivar object_getInstanceVariable ( id obj, const char *name, void **outValue );
// 返回指向給定對象分配的任何額外字節(jié)的指針
void * object_getIndexedIvars ( id obj );
// 返回對象中實例變量的值
id object_getIvar ( id obj, Ivar ivar );
// 設置對象中實例變量的值
void object_setIvar ( id obj, Ivar ivar, id value );
- 如果實例變量的Ivar已經(jīng)知道，那么調(diào)用object_getIvar會比object_getInstanceVariable函數(shù)快，相同情況下，object_setIvar也比object_setInstanceVariable快。
3.針對對象的類進行操作的函數(shù)，這類函數(shù)包含：
// 返回給定對象的類名
const char * object_getClassName ( id obj );
// 返回對象的類
Class object_getClass ( id obj );
// 設置對象的類
Class object_setClass ( id obj, Class cls );
以上內(nèi)容是第一部分內(nèi)容，完。
