iOS 类、元类、Block (基于 OC 2.0)

作者: 阿斯兰iOS | 来源:发表于2019-08-02 14:44 被阅读0次

讲述 objective-c 2.0 对 class 的定义，类、元类的关系，一些面试题，并且对 block 简单说明。

网上很多文章对 class 的定义还是 OC 1.0 的，因此自己写一篇记录一下。

iOS 运行时代码 objc4 的下载地址：
https://opensource.apple.com/tarballs/objc4/

打开源代码，Xcode 同时按 cmd + shift + o，输入 Class 可以搜到相关定义。

1、简化定义

// Class
typedef struct objc_class *Class;
// id
typedef struct objc_object *id;

// 类
struct objc_class : objc_object {
    // 省略部分成员变量以及方法...
}

// 对象
struct objc_object {
    // 省略部分成员变量以及方法...
}

// Object
@interface Object {
    Class isa;
}
@end

// NSObject
@interface NSObject <NSObject> {
    Class isa;
}

可见，类和对象是结构体。

类也是对象，因为对象和类都是结构体 objc_object。

2、详细定义

2.1 对象

结构体 objc_object：

struct objc_object {
private:
    isa_t isa;
    // 省略部分成员变量以及方法...
}

联合体 isa_t：

union isa_t {
    Class cls;
    uintptr_t bits;
    // 省略部分成员变量以及方法...
};

对象有个 isa_t ，isa_t 有个 Class 指向对象的类。
类也是对象，类的 isa_t 的 Class 指向元类。
元类保存类方法，类保存实例方法。

2.2 类

结构体 objc_class：

struct objc_class : objc_object {
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    // class_rw_t 有类的方法和属性列表。
    class_rw_t *data() { 
        return bits.data();
    }
    // 省略部分成员变量以及方法...
}

superclass 是父类，
cache_t 是方法缓存，
class_data_bits_t 包含 class_rw_t，
class_rw_t 里面有类的方法和属性列表。

结构体 class_rw_t：

struct class_rw_t {
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;

    const class_ro_t *ro;
    Class firstSubclass;
    Class nextSiblingClass;

    char *demangledName;
    // 省略部分成员变量以及方法...
};

method_array_t 是个类，保存方法列表，
property_array_t 保存属性列表，
protocol_array_t 保存协议列表。

objc_object 可以简单理解为，有个 isa 指向对象的类，
objc_class 比 objc_object 多了方法列表、属性列表。
然后类、元类也是对象。

3、对象、类、元类的关系

类、元类，也是对象，他们的关系如下图所示：

对象、类、元类关系图

Root class 是 NSObject。

对于 instance，没有 superclass 线，isa 都指向自己的类。
对于 class，superclass 指向父类，isa 指向元类。
对于 meta，superclass 指向父类，isa 指向同一个元类，即 NSObject meta class。
NSObject 没有父类，所以 superclass 指向 nil。
NSObject meta class 的 isa 指向 NSObject 类，形成闭环。

为什么所有元类的 isa 都指向 NSObject meta class？
为什么 NSObject meta class 的 superclass 要指向 NSObject？
有没有大神解答一下😑。

查找对象方法时，根据对象的 isa 找到对象的类，如果子类没有找到方法，就通过 superclass 找到父类，在父类查找方法。

查找类方法时，根据类的 isa 找到元类，如果子元类没有找到，就通过 superclass 找到父元类，在父元类查找方法。

如果根元类，即 NSObject meta class 也没找到，就会去 superclass，也就是 NSObject 类查找。

如果想深入了解，可以看这篇文章：《神经病院Objective-C Runtime入院第一天——isa和Class》。

4、一些题目

4.1

类调用实例方法，是否会崩溃？

// 分类
@interface NSObject (Test)
+ (void)ioo;
@end

@implementation NSObject (Test)
- (void)ioo {
    NSLog(@"%@", NSStringFromSelector(_cmd));
}
@end

测试用例：

- (void)test1 {
    [NSObject ioo];     // 1、
    [NSString ioo];     // 2、
}

1 和 2，哪个会崩溃？

答案是都不会崩溃。

对于 [NSObject ioo] ，先在元类 NSObject meta class 里面找不到 ioo 方法，然后在元类的父类 NSObject class 里找到了。元类 NSObject meta class 的 superclass 指向类 NSObject class 。

对于 [NSString ioo]，先在 NSString meta class 里面找不到，然后在 superclass 指向的 NSObject meta class 里也找不到，最后在 NSObject meta class 的 superclass 指向的 NSObject class 里找到了。

4.2

下面的代码是否会崩溃

// 分类
@interface NSString (Test)
+ (void)sioo;
@end

@implementation NSString (Test)
- (void)sioo {
    NSLog(@"%@", NSStringFromSelector(_cmd));
}
@end


- (void)test2 {
    [NSString ioo];    // 1、
    [NSString sioo];    // 2、
}

1 不会崩溃，2 会崩溃。

对于 [NSString sioo]，寻找的过程是 NSString meta class、NSObject meta class、NSObject，而方法 sioo 是定义在 NSString 里面，所以崩溃了。

另外，假设只声明但没有实现方法 - (void)fun，
对于 [[NSObject new] fun]，在 NSObject 里找不到，而 NSObject 的父类是 nil，因此崩溃了。

4.3

下面代码输出什么

- (void)test3 {
    BOOL b1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];
    BOOL b2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
    BOOL b3 = [(id)[Son class] isKindOfClass:[Son class]];
    BOOL b4 = [(id)[Son class] isMemberOfClass:[Son class]];
    NSLog(@"%d %d %d %d", b1, b2, b3, b4);

    BOOL b5 = [[Son new] isKindOfClass:[Son class]]; 
    BOOL b6 = [[Son new] isMemberOfClass:[Son class]]; 
    NSLog(@"%d %d", b5, b6); 
    
    BOOL b7 = class_isMetaClass([Son class]); // 要 #import <objc/runtime.h>
    BOOL b8 = [Son new].class == [Son class]; 
    BOOL b9 = class_isMetaClass([[Son class] class]);
    NSLog(@"%d %d %d", b7, b8, b9);
}

b1-4 输出 1 0 0 0，
b5-6 输出 1 1，
b7-9 输出 0 1 0。

先看 class 方法：

+ (Class)class {
    return self;
}

- (Class)class {
    return object_getClass(self);
}

Class object_getClass(id obj)
{
    if (obj) return obj->getIsa();
    else return Nil;
}

方法 object_getClass 是获取对象的 isa 指向的 class。
类和对象的 class 方法都返回类，不是元类。
类的 class 方法返回 self，对象的返回所属类。

举个栗子：

po [Son class]
po [[[[Son class] class] class] class]

上面都是输出 Son，不管调用多少次 class，返回的都是 self

然后看下 isMemberOfClass 方法：

+ (BOOL)isMemberOfClass:(Class)cls {
    return object_getClass((id)self) == cls;
}

- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

- (Class)class {
    return object_getClass(self);
}

Class object_getClass(id obj)
{
    if (obj) return obj->getIsa();
    else return Nil;
}

方法 object_getClass 是获取对象的 isa 指向的 class，如果传入的参数是类对象，获取的就是元类了。
方法 isMemberOfClass 会取一次 isa 指向的类，然后进行比较。
如果是对象调用 isMemberOfClass，就是类与类比较。
如果是类调用 isMemberOfClass，就是元类与类比较。

举个栗子：

[(id)[A class] isMemberOfClass:[B class]];

上面代码是 A meta class，与 B class 进行比较，
而不是 A class 与 B class 比较。

最后看下 isKindOfClass ：

+ (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

- (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

- (Class)class {
    return object_getClass(self);
}

Class object_getClass(id obj)
{
    if (obj) return obj->getIsa();
    else return Nil;
}

可见 isKindOfClass 就是 isMemberOfClass 的循环版，会通过 superclass 沿着继承链进行判断。
如果是对象调用 isMemberOfClass，会沿着 class 继承链判断。
如果是类调用 isMemberOfClass，会沿着 meta class 继承链判断。
需要注意的是，NSObject meta class 的 superclass 是 NSObject class，isa 指向自己。
NSObject class 的 superclass 是 nil，isa 指向 NSObject meta class。

对于
BOOL b1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]，
先是 NSObject meta class 与 NSObject class 比较，
然后是 NSObject class 与 NSObject class 比较，所以结果是 1。

总结一下：

- (void)test3 {
    // 类和对象的 class 方法会返回类，不是元类。
    // 类的 class 方法返回 self，对象的返回所属类。
    // isMemberOfClass 会取 isa 指向的类，与参数的类就行比较
    // 如果是对象调用 isMemberOfClass，就是类与类比较
    // 如果是类调用 isMemberOfClass，就是元类与类比较
    // isKindOfClass 会通过 superclass 沿着继承链循环判断
    
    BOOL b1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]; // 1，循环到 NSObject == NSObject
    BOOL b2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]]; // 0，NSObject meta != NSObject
    BOOL b3 = [(id)[Son class] isKindOfClass:[Son class]]; // 0，从 Son meta class 循环到 NSObject 到 nil，都 != Son
    BOOL b4 = [(id)[Son class] isMemberOfClass:[Son class]]; // 0，Son meta != Son
    b3 = [Son isKindOfClass:[Son class]]; // 0，和上面的两句是一样的
    b4 = [Son isMemberOfClass:[Son class]]; // 0，Son meta != Son
    NSLog(@"%d %d %d %d", b1, b2, b3, b4);// 1 0 0 0
    
    BOOL b5 = [[Son new] isKindOfClass:[Son class]]; // 1
    BOOL b6 = [[Son new] isMemberOfClass:[Son class]]; // 1，Son == Son
    NSLog(@"%d %d", b5, b6); // 1 1
    
    
    BOOL b7 = class_isMetaClass([Son class]); // 0，要 #import <objc/runtime.h>
    BOOL b8 = [Son new].class == [Son class]; // 1，Son == Son
    BOOL b9 = class_isMetaClass([[Son class] class]); // 0，[[Son class] class] == Son
    NSLog(@"%d %d %d", b7, b8, b9);// 0 1 0
}

5、Block

最后简单说一下 block。block 也是对象。

定义一个继承自 NSObject 的 Test 类，有个 test 方法：

@implementation Test

- (void)test {
    void (^blc)(void) = ^ {
        printf("哈哈哈");
    };
    
    blc();
}

@end

代码转换后， block 语法转换的函数：

// block 的函数，参数是一个 block 指针
static void __Test__test_block_func_0(struct __Test__test_block_impl_0 *__cself) {
    printf("哈哈哈");
}

block 转换成结构体：

// 自定义 block 的结构体
struct __Test__test_block_impl_0 {
    struct __block_impl impl; // block 的基本定义
    struct __Test__test_block_desc_0* Desc; // block 的数据
    
    // 构造函数。
    // fp 是 block 的函数的指针，desc 是 block 的数据。
    __Test__test_block_impl_0(void *fp, struct __Test__test_block_desc_0 *desc, int flags=0) {
        // 省略部分代码
    }
};

再看 block 的基本定义：

// block 的基本定义
struct __block_impl {
    void *isa; // block 的类
    int Flags;
    int Reserved;
    void *FuncPtr; // 指向 block 的函数
};

里面有个 isa 指针，指向 block 的类，可以是堆、栈、全局 block。

打印输出 block 的继承链：

(lldb) po [blc class]
__NSGlobalBlock__

(lldb) po [blc superclass]
__NSGlobalBlock

(lldb) po [[blc superclass] superclass]
NSBlock

(lldb) po [[[blc superclass] superclass] superclass]
NSObject

(lldb) po [[[[blc superclass] superclass] superclass] superclass]
nil

具体可以看我的另一篇文章笔记-《Objective-C高级编程 iOS与OS X多线程和内存管理》，在 2.3 章节记录 Blocks 的实现。

如有错误，欢迎指正。

iOS 类、元类、Block (基于 OC 2.0)

1、简化定义

2、详细定义

2.1 对象

2.2 类

3、对象、类、元类的关系

4、一些题目

4.1

4.2

4.3

5、Block

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读