iOS 类、元类、Block (基于 OC 2.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  {
    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、对象、类、元类的关系

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


iOS 类、元类、Block (基于 OC 2.0)_第1张图片
对象、类、元类关系图

Root class 是 NSObject。

  1. 对于 instance,没有 superclass 线,isa 都指向自己的类。
  2. 对于 class,superclass 指向父类,isa 指向元类。
  3. 对于 meta,superclass 指向父类,isa 指向同一个元类,即 NSObject meta class。
  4. NSObject 没有父类,所以 superclass 指向 nil。
  5. 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 
    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 
    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))