Runtime(2)

文章:iOS开发-Runtime 详解iOS RunTime 之数据结构iOS 模块分解—「Runtime面试、工作」Runtime 源码

 

一、简介

C++ 是基于静态类型,而 Objective-C 是基于动态运行时类型。用 C++ 编写的程序通过编译器直接把函数地址硬编码进入可执行文件;Objective-C 则不能,而是在程序运行的时,利用 Runtime 根据条件判断作出决定。函数标识与函数实现之间的关联可以动态修改RuntimeObjective 不可缺少的重要一部分。

Runtime 又叫运行时,是一个用 C 和汇编编写的动态库,平时编写的 Objc 代码,底层都是基于它来实现的。它将 OCC 紧密关联并提供动态特性,这个系统主要做两件事:

1、封装 C 语言的结构体和函数,让开发者在运行时创建、检查或者修改类、对象和方法等。

2、传递消息,找出方法的最终执行代码。

①、静态类型编程语言在编译期就确定了函数的地址,OC 的方法调用(消息发送)是运行时动态确定(代价是性能下降,objc_class 中的 objc_cache 就是用来补偿这种性能下降的);
②、类层次体系查找(isa + objc_method_list+ 消息转发(动态解析 => 备用接收者 => 签名+打包+完整转发)

动态加载:NSBundle类提供了许多面向对象的便捷接口用于动态加载;比如 Retina 设备自动加载 @2x 的图片。

[receiver message];  
// 底层运行时会被编译器转化为:objc_msgSend(receiver, selector)
[receiver message:(id)arg...]; 
// 底层运行时会被编译器转化为:objc_msgSend(receiver, selector, arg1, arg2, ...)

也就是说,有很多类和成员变量在编译时是不知道的,而在运行时,编写的代码会转换成完整的确定的代码运行。因此,只有编译器是不够的,我们还需要一个运行时系统(Runtime system)来处理编译后的代码。

 

二、作用

ObjcRuntime 相关:

①、通过 Objective-C 源代码
②、通过 Foundation 框架的 NSObject 类定义的方法
③、通过对 Runtime 库函数的直接调用

 

1Objective-C 源代码

多数情况开发者只需要编写 Objc 代码即可,Runtime 系统自动在幕后搞定一切,就像简介中调用方法一样,编译器会将 Objc 代码转换成运行时代码,在运行时确定数据结构和函数。

 

2、通过 Foundation 框架的 NSObject 类定义的方法

Cocoa 程序中绝大部分类都是继承了 NSObject 的行为的子类。(NSProxy 是个抽象超类)

NSObject 类有时仅仅定义了完成某件事情的模板,并没有提供实现的代码。例如 -description 方法,该方法返回类内容的字符串表示,用来调试程序。NSObject 类并不知道子类的内容,所以它只是返回类的名字和对象的地址。

一些 NSObject 的方法可以从 Runtime 系统中获取信息,允许对象进行自我检查。例如:

  • -class 方法返回对象的类;
  • -isKindOfClass:-isMemberOfClass: 方法检查对象是否存在于指定的类的继承体系中
  • -respondsToSelector: 检查对象能否响应指定的消息;
  • -conformsToProtocol: 检查对象是否实现了指定协议类的方法;
  • -methodForSelector: 返回指定方法实现的地址。

 

3、通过对 Runtime 库函数的直接调用

Runtime 系统是具有公共接口的动态共享库。头文件存放于 /usr/include/objc 目录下,使用时 #import <objc/Runtime.h> 头文件即可。

许多函数可以让你使用纯 C 代码来实现 Objc 中同样的功能。除非是写一些 Objc 与其他语言的桥接或是底层的 debug 工作,否则一般不会用到这些 C 语言函数。

 

三、术语及其数据结构

SEL

它是 selectorObjc 中的表示(Swift 中是 Selector 类)。selector 是方法选择器,本质上是一个根据方法名 hash 化了的 key 值,为了加快查询方法实现的速度。它的数据结构是:

typedef struct objc_selector *SEL;  // An opaque type that represents a method selector.

可以看出它是个映射到方法的 C 字符串,你可以通过 Objc 编译器命令 @selector() 或者 Runtime 系统的 sel_registerName 函数来获取一个 SEL 类型的方法选择器。

注意:不同类中相同名字的方法所对应的 selector 是相同的,由于变量的类型不同,所以不会导致它们调用方法实现混乱。

 

id

id 是一个参数类型,它是指向某个类的实例的指针。定义如下:

typedef struct objc_object *id;
struct objc_object { Class isa; };

objc_object 结构体包含一个 isa 指针,根据 isa 指针就可以找到对象所属的类。

注意:isa 指针在代码运行时并不总指向实例对象所属的类型,所以不能用它来确定类型。可以用对象的 -class 方法和 Runtimeobject_getClass() 方法。

Direct access to Objective-C's isa is deprecated in favor of object_getClass()

KVO 的实现机理就是将被观察对象的 isa 指针指向一个中间类而不是真实类型。

 

Class

typedef struct objc_class *Class;

Class 其实是指向 objc_class 结构体的指针。objc_class 的数据结构如下:

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    /*  父类  */
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;   
    /*  类名  */
    const char * _Nonnull name                               OBJC2_UNAVAILABLE; 

    /* 类的版本信息,默认为 0 */
    long version                                             OBJC2_UNAVAILABLE;

    /* 类信息,供运行时期使用的一些位标识。

       如 CLS_CLASS (0x1L) 表示该类为普通 class,其中包含实例方法和变量;
         CLS_META (0x2L) 表示该类为 metaclass,其中包含类方法;
     */ 
    long info                                                OBJC2_UNAVAILABLE;

    /* 实例变量大小(包括从父类继承下来的实例变量)*/
    long instance_size                                       OBJC2_UNAVAILABLE;  

    /* 成员变量地址列表 */
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE; 

    /* 方法地址列表,与 info 的一些标志位有关。

       如 CLS_CLASS (0x1L),则存储实例方法;CLS_META (0x2L),则存储类方法;
     */
    struct objc_method_list * _Nullable * _Nullable methodLists   OBJC2_UNAVAILABLE;

    /* 缓存最近使用的方法地址,用于提升效率 */
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE; 

    /* 存储该类声明遵守的协议的列表 */
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;  
#endif

} OBJC2_UNAVAILABLE;

objc_class 可以看到:一个运行时类中关联了它的父类指针、类名、成员变量、方法、缓存以及附属的协议。

其中 objc_ivar_listobjc_method_list 分别是成员变量列表和方法列表:

// 成员变量列表
struct objc_ivar_list {
    int ivar_count                                           OBJC2_UNAVAILABLE;
#ifdef __LP64__
    int space                                                OBJC2_UNAVAILABLE;
#endif
    /* variable length structure */
    struct objc_ivar ivar_list[1]                            OBJC2_UNAVAILABLE;
}                                                            OBJC2_UNAVAILABLE;

// 方法列表
struct objc_method_list {
    struct objc_method_list *obsolete                        OBJC2_UNAVAILABLE;

    int method_count                                         OBJC2_UNAVAILABLE;
#ifdef __LP64__
    int space                                                OBJC2_UNAVAILABLE;
#endif
    /* variable length structure */
    struct objc_method method_list[1]                        OBJC2_UNAVAILABLE;
}

由此可见,我们可以动态修改 methodList 的值来添加成员方法,这也是 Category 实现的原理,同样解释了 Category 不能添加属性的原因。深入理解 Objective-C: Category

objc_ivar_list 结构体用来存储成员变量的列表,而 objc_ivar 则是存储了单个成员变量的信息;同理,objc_method_list 结构体存储着方法数组的列表,而单个方法的信息则由 objc_method 结构体存储。

值得注意的是,由 objc_objectobjc_class 的代码可以看出,objc_class 中也有一个 isa 指针,这说明 objc_class 也是一个对象,分别称作类对象(class object)和实例对象(instance object)。

实例对象 objc_objectisa 指针指向的类结构称为 class,也就是该对象所属的类,其中存放着普通成员变量与动态方法(" - " 开头的方法);

类对象 objc_classisa 指针指向的类结构称为 meta class,其中存放着 static 类型的成员变量与 static 类型的方法(" + " 开头的方法)。

为了处理类和对象的关系,Runtime 库创建了 Meta Class (元类) ,类对象所属的类 Class 就叫做元类。Meta Class 表述了类对象本身所具备的元数据。

开发者所熟悉的类方法,就源自于 Meta Class。可以理解为类方法就是类对象的实例方法。每个类仅有一个类对象,而每个类对象仅有一个与之相关的元类。

当调用 +alloc 的消息时,这个消息实际上被发送给了一个类对象(Class Object),这个类对象必须是一个元类的实例,而这个元类同时也是一个根元类(Root Meta Class)的实例。所有元类的 isa 指针最终都指向根元类。

[NSObject.class alloc];    // [NSObject alloc]

所以当 [NSObject alloc] 这条消息发送给类对象的时候,运行时代码 objc_msgSend() 会去它元类中查找能够响应消息的方法实现,如果找到了,就会对这个类对象执行方法调用。

Meta Class

实线是 super_class 指针,虚线是 isa 指针。而根元类的父类是 NSObjectisa 指向了自己,NSObject 没有父类。

最后 objc_class 中还有一个 objc_cache 缓存,它的作用很重要,后面会提到。

 

Method

代表类中某个方法的类型。

typedef struct objc_method *Method;

struct objc_method {
    SEL _Nonnull method_name            OBJC2_UNAVAILABLE;   // 方法名
    char * _Nullable method_types       OBJC2_UNAVAILABLE;   // 方法类型
    IMP _Nonnull method_imp             OBJC2_UNAVAILABLE;   // 方法实现
}      
  • method_name 类型为 SEL
  • method_types 是个 char 指针,存储方法的参数类型和返回值类型
  • method_imp 指向了方法的实现,本质是一个函数指针

 

Ivar

表示成员变量的类型。

typedef struct objc_ivar *Ivar;

struct objc_ivar {
    char * _Nullable ivar_name                OBJC2_UNAVAILABLE;
    char * _Nullable ivar_type                OBJC2_UNAVAILABLE;
    int ivar_offset                           OBJC2_UNAVAILABLE;   // 基地址偏移字节

#ifdef __LP64__
    int space                                 OBJC2_UNAVAILABLE;  // 占用空间
#endif
}    

 

IMP

objc.h 中定义如下:

// 参数 1 : 如果是实例方法,则是 self 的内存地址;如果是类方法,则是指向元类的指针
typedef id (*IMP)(id, SEL, ...);

它就是一个由编译器生成的函数指针,指向方法实现的首地址。当你发起一个 ObjC 消息之后,最终它会执行哪段代码,就是由这个函数指针指定的。而 IMP 这个函数指针就指向了这个方法的实现。

如果得到了执行某个实例某个方法的入口,就可以绕开消息传递阶段,直接执行方法,这在后面 Cache 中会提到。

你会发现 IMP 指向的方法与 objc_msgSend() 函数类型相同,参数都包含 idSEL 类型。每个方法名都对应一个 SEL 类型的方法选择器,而每个实例对象中的 SEL 对应的方法实现肯定是唯一的,通过一组 idSEL 参数就能确定唯一的方法实现地址。一个确定的方法也只有唯一的一组 idSEL 参数。

 

Cache

runtime.h 中定义如下:

typedef struct objc_cache *Cache

struct objc_cache {
    /* 指定分配 cache buckets 的总数。在方法查找中,Runtime 使用这个字段确定数组的索引位置。*/
    unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;

    /* 实际占用cache buckets的总数 */
    unsigned int occupied                                    OBJC2_UNAVAILABLE;

    /*  指定 Method 数据结构指针的数组。这个数组可能包含不超过 mask + 1 个元素。

       指针可能是 NULL,表示这个缓存 bucket 没有被占用,另外被占用的 bucket 可能是不连续的。这个数组可能会随着时间而增长
     */
    Method _Nullable buckets[1]                              OBJC2_UNAVAILABLE;
};

Cache 优化方法调用的性能。每当实例对象接收到一个消息时,优先在 Cache 中查找,它不会直接在 isa 指针指向的类的方法列表中遍历查找能够响应的方法,因为每次都要查找效率太低了。

Runtime 系统会把被调用的方法存到 Cache 中,如果一个方法被调用,那么它有可能今后还会被调用,下次查找的时候就会效率更高。就像计算机组成原理中 CPU 绕过主存先访问 Cache 一样。

 

Property

typedef struct objc_property *Property;
typedef struct objc_property *objc_property_t;  // 这个更常用

可以通过 class_copyPropertyList()protocol_copyPropertyList() 方法获取类和协议中的属性:

OBJC_EXPORT objc_property_t _Nonnull * _Nullable
class_copyPropertyList(Class _Nullable cls, unsigned int * _Nullable outCount)
    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

OBJC_EXPORT objc_property_t _Nonnull * _Nullable
protocol_copyPropertyList(Protocol * _Nonnull proto,
                          unsigned int * _Nullable outCount)
    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

返回的是属性列表,列表中每个元素都是一个 objc_property_t 指针。

property_getName() 用来查找属性的名称,返回 c 字符串。
property_getAttributes() 函数挖掘属性的真实名称和 @encode 类型,返回 c 字符串。
class_getProperty()protocol_getProperty() 通过给出属性名在类和协议中获得属性的引用。

类对象结构图

 

四、消息

体会官方文档中的 messages aren’t bound to method implementations until Runtime消息直到运行时才会与方法实现进行绑定

这里要清楚一点,objc_msgSend() 方法看起来好像返回了数据,其实 objc_msgSend() 从不返回数据,而是方法在运行时被调用实现后才会返回数据。下面详细叙述消息发送的步骤:

消息发送

①、首先检测这个 selector 是不是要忽略。比如 Mac OS X 开发,有了垃圾回收就不理会 retainrelease 这些函数;

②、检测这个 selectortarget 是不是 nilObjc 允许对一个 nil 对象执行任何方法不会 Crash,因为运行时会被忽略掉。

③、如果上面两步都通过了,那么就开始查找这个类的实现 IMP,先从 cache 里查找,如果找到了就运行对应的函数去执行相应的代码。

④、如果 cache 找不到就找类的方法列表中是否有对应的方法。

⑤、如果类的方法列表中找不到就到父类的方法列表中查找,一直找到 NSObject 类为止。

⑥、如果还找不到,就要开始进入动态方法解析了,后面会提到。

在消息的传递中,编译器会根据情况在 objc_msgSend()objc_msgSend_stret()objc_msgSendSuper()objc_msgSendSuper_stret() 这四个方法中选择一个调用。如果消息是传递给父类,那么会调用名字带有 Super 的函数;如果消息返回值是数据结构而不是简单值时,会调用名字带有 stret 的函数发送消息和接收返回值。

 

1、方法中的隐藏参数

我们经常使用关键字 self,但是 self 是如何获取当前方法的对象呢?

其实,这也是 Runtime 系统的作用,self 是在方法运行时被动态传入的。

objc_msgSend() 找到方法对应实现时,它将直接调用该方法实现,并将消息中所有参数都传递给方法实现,同时,它还将传递两个隐藏参数:

  • self 当前方法的对象指针,接受消息的对象
  • _cmd 当前方法的 SEL 指针,方法选择器

因为在源代码方法的定义中,我们并没有发现这两个参数的声明。它们是在代码被编译时被插入方法实现中的。尽管这些参数没有被明确声明,在源代码中我们仍然可以引用它们。

这两个参数中,self 更实用。它是在方法实现中访问消息接收者对象的实例变量的途径。

这时我们可能会想到另一个关键字 super,实际上 super 关键字接收到消息时,编译器会创建一个 objc_super 结构体:

struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained _Nonnull id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained _Nonnull Class class;
#else
    __unsafe_unretained _Nonnull Class super_class;
#endif
    /* super_class is the first class to search */
};

这个结构体指明了消息应该被传递给特定的父类。

receiver 仍然是 self 本身,当我们想通过 [super class] 获取父类时,编译器其实是将指向 selfid 指针和 classSEL 传递给了 objc_msgSendSuper() 函数。只有在 NSObject 类中才能找到 class 方法,然后 class 方法底层被转换为 object_getClass(), 接着底层编译器将代码转换为 objc_msgSend(objc_super->receiver, @selector(class)),传入的第一个参数是指向 selfid 指针,与调用 [self class] 相同,所以我们得到的永远都是 self 的类型。因此你会发现:

NSLog(@"%@", NSStringFromClass([super class]));

2018-11-05 11:30:25.082134+0800 Demo[22838:128408] ViewController   // 当前类

 

2、获取方法地址

NSObject 中有 - methodForSelector: 实例方法,你可以用它来获取某个方法选择器对应的 IMP

{
     CFTimeInterval ti = CFAbsoluteTimeGetCurrent();
        
     for (int i = 0; i < 10000; i++) {
          [self fail:YES];
     }
     NSLog(@"%f", CFAbsoluteTimeGetCurrent() - ti);
}

- (void)fail:(BOOL)value
{

}

2018-11-05 13:06:22.683838+0800 Demo[36187:211037] 4.104993


{
     void (*setter)(id, SEL, BOOL) = (void (*)(id, SEL, BOOL))[self methodForSelector:@selector(fail:)];

     CFTimeInterval ti = CFAbsoluteTimeGetCurrent();
    
     for (int i = 0; i < 10000; i++) {
          setter(self, @selector(fail:), YES);
     }
     NSLog(@"%f", CFAbsoluteTimeGetCurrent() - ti);
}

2018-11-05 13:05:48.480498+0800 Demo[36095:209893] 3.751424

虽然是更高效的调用方法,但这种做法很少用,除非是需要持续大量重复调用某个方法的情况,才会选择使用,以免消息发送泛滥

注意:methodForSelector: 方法是由 Runtime 系统提供的,而不是 Objc 自身的特性

 

五、动态方法解析

如果用关键字 @dynamic.m 文件中修饰一个属性,表明我们会为这个属性动态提供存取方法,编译器不会再默认生成该属性的 settergetter 方法。

@dynamic propertyName;

这时,可以通过分别重载 resolveInstanceMethod:resolveClassMethod: 方法添加实例方法实现和类方法实现。

Runtime 系统会在 Cache 和类、父类的方法列表中找不到要执行的方法时,会调用 resolveInstanceMethod:resolveClassMethod: 来给开发者一次动态添加方法实现的机会。

void dynamicIMP(id self, SEL _cmd) {
    // implementation ....
}

@implementation MyClass

+ (BOOL)resolveInstanceMethod:(SEL)aSEL
{
     if (aSEL == @selector(resolveThisMethodDynamically)) {
          class_addMethod([self class], aSEL, (IMP) dynamicIMP, "v@:");
          return YES;
     }
     return [super resolveInstanceMethod:aSEL];
}

@end

上面为 resolveThisMethodDynamically 方法添加了实现内容,就是 dynamicIMP 方法中的代码。其中 "v@:" 表示返回值和参数,这个符号表示的含义见:Type Encoding

动态方法解析会在消息转发机制侵入前执行,动态方法解析器将会首先给予提供该方法选择器对应的 IMP 的机会。如果你想让 aSEL 被传送到转发机制,就让 resolveInstanceMethod: 方法返回 NO

 

六、消息转发
消息转发

①、通过 resolveInstanceMethod: 方法决定是否动态添加方法。如果返回 YES 则通过 class_addMethod() 动态添加方法,消息得到处理,结束;如果返回 NO,则进入下一步;

②、进入 forwardingTargetForSelector: 方法,用于指定备选对象响应这个selector,不能指定为 self。如果返回某个对象则会调用对象的方法,结束。如果返回 nil,则进入下一步;

③、通过 methodSignatureForSelector: 方法签名,如果返回 nil,则消息无法处理。如果返回 methodSignature,则进入下一步;

④、调用 forwardInvocation: 方法,可以通过 anInvocation 对象做很多处理,比如修改实现方法、修改响应对象等,如果方法调用成功,则结束。如果失败,则进入 doesNotRecognizeSelector 方法,若我们没有实现这个方法,那么就会 crash

 

1、重定向

消息转发机制执行前,Runtime 系统允许我们替换消息的接收者为其他对象。通过 - (id)forwardingTargetForSelector:(SEL)aSelector 方法。

- (id)forwardingTargetForSelector:(SEL)aSelector
{
     if(aSelector == @selector(xxx:)){
          return otherObj;
     }
     return [super forwardingTargetForSelector:aSelector];
}

如果此方法返回 nil 或者 self,则会计入消息转发机制(forwardInvocation:),否则将向返回的对象重新发送消息。

 

2、转发

当动态方法解析不做处理返回 NO 时,则会触发消息转发机制。这时 forwardInvocation: 方法会被执行,我们可以重写这个方法来自定义我们的转发逻辑:

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
     return [otherObj methodSignatureForSelector:aSelector];
}

/**
 *  @param  anInvocation  封装了原始的消息和消息的参数
 */
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
     // 判断 otherObj 对象是否实现了方法
     if ([otherObj respondsToSelector:[anInvocation selector]]) {
          [anInvocation invokeWithTarget:otherObj];
     }
     else {
          [super forwardInvocation:anInvocation];
     }
}

开发者可以实现 forwardInvocation: 方法来对不能处理的消息做一些处理。也可以将消息转发给其他对象处理,而不抛出错误。

参数 anInvocation 是从哪来的?

forwardInvocation: 消息发送前,Runtime 系统会向对象发送 methodSignatureForSelector: 消息,并取到返回的方法签名用于生成 NSInvocation 对象。所以重写 forwardInvocation: 的同时也要重写 methodSignatureForSelector: 方法,否则会抛异常。

当一个对象由于没有相应的方法实现而无法相应某消息时,运行时系统将通过 forwardInvocation: 消息通知该对象。每个对象都继承了 forwardInvocation: 方法。但是 NSObject 中的方法实现只是简单的调用了 doesNotRecognizeSelector:。通过实现自己的 forwardInvocation: 方法,我们可以将消息转发给其他对象。

forwardInvocation: 方法就是一个不能识别消息的分发中心,将这些不能识别的消息转发给不同的接收对象,或者转发给同一个对象,再或者将消息翻译成另外的消息,亦或者简单的 “吃掉” 某些消息,因此没有响应也不会报错。这一切都取决于方法的具体实现。

forwardInvocation: 方法只有在消息接收对象中无法正常响应消息时才会被调用。所以,如果我们想往一个对象将一个消息转发给其他对象时,要确保这个对象不能有该消息的所对应的方法。否则,forwardInvocation: 将不可能被调用。

 

3、转发和多继承

转发和继承相似,可用于为 Objc 编程添加一些多继承的效果。就像下图那样,一个对象把消息转发出去,就好像它把另一个对象中的方法接过来或者 “继承” 过来一样。

转发和多继承

在上图中 WarriorDiplomat 没有继承关系,但是 Warriornegotiate 消息转发给了 Diplomat 后,就好似 DiplomatWarrior 的超类一样。这使得在不同继承体系下的两个类可以实现继承对方的方法,消息转发弥补了 Objc 不支持多继承的性质,也避免了因为多继承导致单个类变得臃肿复杂。

 

4、转发与继承

虽然转发可以实现继承的功能,但是 NSObject 还是必须表面上很严谨,像 respondsToSelector:isKindOfClass: 这类方法只会考虑继承体系,不会考虑转发链。

如果判断上图中的 Warrior 对象是否能响应 negotiate 消息:

if ( [aWarrior respondsToSelector:@selector(negotiate)] )
    ...

尽管 Warrior 能转发消息给 Diplomat 类响应消息,但返回依然是 NO

如果想要让外界以为 Warrior 继承到了 Diplomatnegotiate 方法,可以重新实现 respondsToSelector:isKindOfClass: 来加入你的转发算法:

- (BOOL)respondsToSelector:(SEL)aSelector
{
     if ( [super respondsToSelector:aSelector] )
          return YES;
     else {
          /* Here, test whether the aSelector message can     *
           * be forwarded to another object and whether that  *
           * object can respond to it. Return YES if it can.  */
     }
     return NO;
}

除了 respondsToSelector:isKindOfClass: 之外,instancesRespondToSelector: 中也应该写一份转发算法。如果使用了协议,conformsToProtocol: 同样需要。

如果一个对象想要转发它接受的任何远程消息,那得重新实现 - methodSignatureForSelector: 返回准确的方法描述 ,这个方法会最终响应被转发的消息,从而生成一个确定的 NSInvocation 对象描述消息和消息参数。这个方法最终响应被转发的消息。

 

七、健壮的实例变量(Non Fragile ivars)

Runtime 的现行版本中,最大的特点就是健壮的实例变量

当一个类被编译时,实例变量的布局也就形成了,它表明访问类的实例变量的位置。从对象头部开始,实例变量依次根据自己所占空间而产生位移:

上图左边是 NSObject 类的实例变量布局,右边是我们写的类的布局,也就是在超类后面加上我们自己类的实例变量,看起来不错。但试想如果那天苹果更新了 NSObject 类,发布新版本的系统的话,那就悲剧了:

我们自定义的类被划了两道线,那是因为那块区域跟超类重叠了。唯有苹果将超类改为以前的布局才能拯救我们,但这样也导致它们不能再拓展它们的框架了,因为成员变量布局被死死地固定了。在脆弱的实例变量(Fragile ivars)环境下我们需要重新编译继承自 Apple 的类来恢复兼容性。那么在健壮的实例变量下会发生什么呢?

健壮的实例变量自动偏移

在健壮的实例变量下编译器生成的实例变量布局跟以前一样,但是当 runtime 系统检测到与超类有部分重叠时它会调整你新添加的实例变量的位移,那样你在子类中新添加的成员就被保护起来了。

需要注意的是在健壮的实例变量下,不要使用 sizeof(cls),而是用 class_getInstanceSize(cls) 代替;也不要使用 offsetof(cls, ivar),而要用 ivar_getOffset(class_getInstanceVariable(cls, "ivar")) 来代替。

You may also like...