重新认识id 以及 Class

id:类 class:对象
我们首先写一个Class去看系统的 API：

1
typedef struct objc_class *Class;

这时我们可以看到下面有个id 类型的结构体,并且里面只有一个Class类型的指针isa：

1
2
3
4
typedef struct objc_object *id;   
struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

我们在来看一下objc_class 的结构体里面有什么：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct objc_class {	
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;         //元类指针
#if !__OBJC2__                                         //这个下面的现在已经不用了！！！
	
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;    //父类
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;    //类名
    long version                                             OBJC2_UNAVAILABLE;    //类的版本
    long info                                                OBJC2_UNAVAILABLE;    //信息
    long instance_size                                       OBJC2_UNAVAILABLE;    //内存布局
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;    //变量列表
    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;
/* Use `Class` instead of `struct objc_class *` */            #if 这个已经废弃了，现在使用Class！！！

我相信很多人学习runtime的时候都看过这个代码，并且很多书籍也以上面的代码来讲解runtime的。其实现在这个已经废弃了，从上面的代码我们看到类实例(对象)中只有一个元素，isa指针，这个指针指向的是实例所述的类，类结构体中也有一个isa指针，其他的我好像是看不出来了，现在我们从objc源代码看一下类真正的结构：
objc_class
代码摘自objc4-750版本，代码太长，所以只看下属性:

1
2
3
4
5
6
7
8
9
10
struct objc_class : objc_object {
    // Class ISA;  	          //isa指针注释掉了,暂且不管
    Class superclass;         //父类指针，
    cache_t cache;             // formerly cache pointer and vtable                   //缓存，应该是我们知道的缓存方法的cache吧
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags             //应该是类存储的字节吧
    class_rw_t *data() {         //我们的方法列表、属性列表、变量什么的应该在这里面，，，往下找
        return bits.data();
    }
	......
}

只有这几个属性，我们的方法列表、属性列表、变量什么的哪去了？我觉得应该跟data()有关，一看bits就是存数据的，data()是class_rw_t类型的，应该能从class_rw_t定义里面找到原因，来看下class_rw_t：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;                    //版本信息
    const class_ro_t *ro;
    method_array_t methods;              //方法列表
    property_array_t properties;         //属性列表
    protocol_array_t protocols;          //协议列表
    Class firstSubclass;
    Class nextSiblingClass;
    char *demangledName;
#if SUPPORT_INDEXED_ISA
    uint32_t index;
#endif
    ......
}

看到了我们熟悉的方法列表、属性列表、协议列表，又看到了一个跟class_rw_t一样的东东class_ro_t，继续深入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;              //实例对象大小
#ifdef __LP64__
    uint32_t reserved;
#endif 
    const uint8_t * ivarLayout;
    const char * name;                  //类名
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;          // 成员变量
    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;
    method_list_t *baseMethods() const {
        return baseMethodList;
    }
};

####class_rw_t 、class_ro_t中的rw、ro应该是readwrite、readonly的意思

  • class_ro_t存储的应该是经过编译之后的类实例的数据，保存了经过编译的变量、属性、实例方法、类方法等，编译之后这些都是readonly类型的，不能再发生改变了，那几个list就是类本来的方法属性协议啥的
  • class_rw_t是readwrite类型的，结合咱们之前了解的runtime的特性，还有里面的几个列表，顿时感觉自己已经猜到了真谛，这个是运行时的真正的类实例的结构，里面的ro是编译之后的类的结构，所以是const类型的，外面这几个列表应该是跟category有关，这么一想好像都通了。。。

我们用Runtime的几个copy列表的方法看一下
class_copyIvarList：获取变量列表，返回的应该是类的class_rw_t里面的class_ro_t下面的ivarlist
class_copyMethodList：因为runtime可以动态添加方法、协议，那么返回的应该是class_rw_t下面的methods，而不是class_ro_t里面的，因为ro是const类型的。
OK，来看下在objc源码中它的实现（看下关键代码就行）:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
```
Ivar *
class_copyIvarList(Class cls, unsigned int *outCount)
{
    const ivar_list_t *ivars;
    Ivar *result = nil;
    unsigned int count = 0;
    if (!cls) {
        if (outCount) *outCount = 0;
        return nil;
    }
    mutex_locker_t lock(runtimeLock);
    assert(cls->isRealized());
    if ((ivars = cls->data()->ro->ivars)  &&  ivars->count) {
        result = (Ivar *)malloc((ivars->count+1) * sizeof(Ivar));
        
        for (auto& ivar : *ivars) {
            if (!ivar.offset) continue;  // anonymous bitfield
            result[count++] = &ivar;
        }
        result[count] = nil;
    }
    if (outCount) *outCount = count;
    return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
```
Method *
class_copyMethodList(Class cls, unsigned int *outCount)
{
    unsigned int count = 0;
    Method *result = nil;
    if (!cls) {
        if (outCount) *outCount = 0;
        return nil;
    }
    mutex_locker_t lock(runtimeLock);
    assert(cls->isRealized());
    count = cls->data()->methods.count();
    if (count > 0) {
        result = (Method *)malloc((count + 1) * sizeof(Method));
        count = 0;
        for (auto& meth : cls->data()->methods) {
            result[count++] = &meth;
        }
        result[count] = nil;
    }
    if (outCount) *outCount = count;
    return result;
}

这样一看，很多我们之前不理解的都能说通了：

  • 类实例是对象，它的isa指针指向类，类也有个isa指针，指向它的元类，类是元类的对象，看定义，objc_class也是objc_object没错，objc_object里面有isa指针，所以objc_class也有isa指针啦。
  • category只能添加方法、不能添加变量的原因也找到了，因为变量是存储在ro里面的，只读，方法列表协议列表在rw中，所以可以动态添加，它们俩存储位置不一样。

#最后总结通过一张图进行总结：objc_class.png

本文部分段落引用了ElaineYin、CornBallast二位大佬的文章。在此表示感谢！