OC底层原理 07: 类的结构分析

主动已经是我对热爱东西表达的极限了

• 类分析初探

通过LLDB查看类在内存中的分布情况

LLDB查看类的内存分布

• 查看内存信息的三种方式：

  1.通过格式化输出当前类（x/4gx objc2）,取类的isa首地址 & ISA_MASK得到类的指针地址，po类的指针地址，得到当前类（objc2），x输出当前指针地址得到objc2类的内存信息

  2. 通过Class提供的API直接输出：x LGPerson.class得到类的内存信息

  3. 通过runtime提供的API直接得到类的内存信息，导入#import <objc/runtime.h>头文件，通过x object_getClass(objc2)得到类的内存信息

通过LLDB结果，发现0x00000001000020e8 与 0x00000001000020c0 都是objc2类，这个时候引入一个新的概念元类，

• 元类

  1.0x00000001000020c0 是isa获取类信息后，所指的类的isa的指针地址，称之为元类，我们说类的类为元类

  2. 类的方法和归属都存在于元类
  3. 元类是创建和编译都是由编译器自动完成的

通过上述元类的理解，我们得知
0x00000001000020e8是objc2的isa 指针地址
0x00000001000020c0 是objc2的 元类

简单了解过元类，系统为什么要创建元类？元类与类有哪写区别？NSObject与元类又有哪些关联和区别？云类的存在又有哪些意义？

我们继续通过isa的走位一层一层来分析，使用LLDB查看类的内存信息与元类的内存信息及NSObject的内存信息如下图所示：

isa走向查看关联

• isa走向描述：
  1. 通过obj2的isa指针地址 & ISA_MASK得到元类的内存信息
  2. 通过元类的isa指针地址 & ISA_MASK得到NSObject

根据isa走向可以得出如下结论：

• isa 对象 -> 类(LGPerson) -> 元类(LGPerson) -> NSObject

在isa走向查看关联图中的最后，打印出了NSObject的内存信息：

(lldb) p/x NSObject.class
(Class) $18 = 0x0000000100333140 NSObject

为什么这里NSObject的内存信息和isa走向打印出来的NSObject的内存信息不一致了？

isa走向NSObject内存信息：0x00000001003330f0
NSObject的内存信息：0x0000000100333140

• 我们知道类的信息在内存中只存在一份，接下来我们开始验证类信息是否只存在一份

• 方式一：通过不同形式定义，直接打印结果

//MARK: - 分析类对象在内存中存在个数
void TTWhetherOrNotTheOnly() {
    
    Class cls1 = [LGPerson class];
    Class cls2 = [LGPerson alloc].class;
    Class cls3 = object_getClass([LGPerson alloc]);
    NSLog(@"\n%p-\n%p-\n%p-",cls1,cls2,cls3);
}

//打印结果如下：
0x1000020f8-
0x1000020f8-
0x1000020f8-

• 方式二：LLDB通过isa走向查看截图如下

isa走向

• 方式三：runtime验证

//MARK: - 分析类对象在内存中存在个数3
void TTWhetherOrNotTheOnlyThree(){
    //NSObjec实例对象
    NSObject *obje3 = [NSObject alloc];
    //NSObject类
    Class clsss = object_getClass(obje3);
    //NSObject元类
    Class metaClass = object_getClass(clsss);
    //NSObject根元类（即NSObject）
    Class rootClass = object_getClass(metaClass);
    //NSObject根元类（即NSObject）
    Class rootClass1 = object_getClass(rootClass);
    NSLog(@"\n实例对象：-> %p\n NSObject类: -> %p\n NSObject元类: -> %p\n NSObject根元类（即NSObject）: -> %p\n NSObject根元类（即NSObject）:-> %p\n",obje3,clsss,metaClass,rootClass,rootClass1);
}

打印结果如下：

runtime验证

通过isa走向，发现最后NSObject的isa指针地址还是指向了NSObject

经典图来了

isa流程图

总结：

• isa走向：
  实例对象（Instance of Subclass） -> 类(Class) -> 元类(meta Class) -> 根元类 NSObject (Root meta Class) -> 自己

• superclass走向：
  类的继承关系：Class -> SuperClass -> RootClass -> nil
  元类的继承关系：meta Class -> SuperClass -> RootClass -> NSObject -> nil

• 【注意】实例对象之间没有继承关系，类之间有继承关系

类的结构分析 objc_class & objc_object

通过对objc_class和objc_object对类进行深入分析，查看结构体在源码中的定义，代码如下：

struct objc_class : objc_object {
    // Class ISA; //8字节
    Class superclass;  //8字节
    cache_t cache;             // formerly cache pointer and vtable。（16字节）
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

      //bits 的 getter函数
    class_rw_t *data() const {
        return bits.data();
    }
      //bits 的setter函数
    void setData(class_rw_t *newData) {
        bits.setData(newData);
    }
    .
    .
    .
//  只复制的了部分，我们需要的，其他的可以自己去查看这里不错全部展示
}

查看objc2的内存信息

查看类信息

• 说明：
  0x00000001000020d8 对应 objc_class 中的isa
0x0000000100333140 对应 objc_class 中的 superclass
0x000000010032d410 对应 objc_class 中的 cache
0x0000801000000000 对应 objc_class 中的 bits

其中：
ISA表示继承于 objc_object的isa
superclass表示父类
cache表示缓存相关信息
bits里面存放类的相关数据（成员、属性、方法、协议等相关数据信息）

objc_class和objc_object在系统中的结构体定义如下：

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

• objc_class 与 objc_object 关系说明

  1. 结构体类型objc_class 继承自objc_object类型，其中objc_object也是一个结构体，且有一个isa属性，所以objc_class也拥有了isa属性

  2. NSObject 是一个类，用它初始化一个实例对象objc2，objc2 满足objc_object 的特性（即有isa属性），主要是因为isa 是由 NSObject 从objc_class继承过来的，而objc_class继承自objc_object，objc_object有isa属性。所以对象都有一个 isa，isa表示指向，来自于当前的objc_object

  3. objc_object（结构体） 是 当前的 根对象，所有的对象都有这样一个特性 objc_object，即拥有isa属性

【面试题】objc_object 与 对象的关系？

所有的对象 都是以objc_object为模板继承过来的

所有的对象 是 来自 NSObject（OC） ，但是真正到底层的 是一个objc_object（C/C++）的结构体类型

【总结】 objc_object 与 对象的关系 是 继承关系

类的内存分布情况及验证

在探究类的内存分布之前，我们先了解一下什么是地址偏移？

• 地址偏移

定义如下代码：

int c[4] = {1,2,3,4};
int *d = c; //赋值c的地址给d

//打印出当前值所在的地址

ADLog(@"通过地址取：%p - %p - %p - %p - %p",&c,&c[0],&c[1],&c[2],&c[3]);

ADLog(@"通过便移取：%p - %p - %p - %p - %p",d,d+1,d+2,d+3,d+4);

       
for (int i=0; i<4; i++){
   int value = c[I];
   ADLog(@"%d",value);
}

打印结果如下：

打印截图

发现 &c和 &c[0]的地址是 相同的，都为 0x7ffeefbff500，因为c数组的 首地址指针代表当前c数组的地址指针所以与 &c[0]是一致的。c数组定义的为int类型的数据类型，所以相差的为4

下面我们通过地址偏移来取出数组c的值，通过LLDB打印C的值，截图如下：

LLDB数据偏移取出值

• p *(地址) ：打印地址获取值

我们通过数组c 的地址偏移 ，取出当前数组的值 。
那么我们是不是也能通过地址偏移 来取出类的数据和所有的值 ？
以LGPerson为例：

通过地址偏移 取数组值的时候，我们知道需要偏移1 位就能够取出值，但是在类中如何偏移？
已知ISA的字节为8，superclass的字节为8，但是cache和bits的字节我们是未知的，要偏移多少位才能取出cache和bits的值？

开始查看的cache所占字节数，进入cache的定义查看源码定义如下（这里只查看定义的字节大小的源码，源码太多不做展示）：

struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
    explicit_atomic<struct bucket_t *> _buckets;  //8（结构体）
    explicit_atomic<mask_t> _mask;  //4 （内部定义的泛型所以为4）
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;
      .
      .
      //省略代码，有兴趣可以自己去查看源码
      .
      .
#if __LP64__
    uint16_t _flags; //  2（unsigned类型）
#endif
    uint16_t _occupied; //2（unsigned类型）

      .
      .
      //省略代码，有兴趣可以自己去查看源码
      .
      .
}

通过cache的源码定义可以得知：cache的字节为16，这个时候我们就可以通过地址偏移得到bits里面存放类的相关数据（成员、属性、方法、协议等相关数据信息）

• 查看bits信息

定义如下四个类：
LGDoctor，LGPerson继承TTTeacher
TTPerson继承LGPerson

//--------------------------  TTTeacher(begin)   --------------------------
@interface TTTeacher : NSObject{
    
    NSString *TeacherOne;
}

@property (nonatomic, copy) NSString *teacherName;

@end
@implementation TTTeacher

@end
//--------------------------  TTTeacher (end)  --------------------------

//--------------------------  LGPerson(begin)   --------------------------
@interface LGPerson : TTTeacher{
    NSString *justOne;
}

@property (nonatomic, copy) NSString *name;

@end
@implementation LGPerson

@end
//--------------------------  LGPerson(end)   --------------------------

1.通过LLDB查看bits信息，截图如下：

bits数据信息

其中$1->data()是源码中调用了bits.data()方法；$2直接打印出bits信息

• 【通过bits查看属性（properties）列表】
  查看class_rw_t在源码中的部分定义如下：

struct class_rw_t {  
    //  只是部分定义

  //成员变量
  const class_ro_t *ro() const {
        auto v = get_ro_or_rwe();
        if (slowpath(v.is<class_rw_ext_t *>())) {
            return v.get<class_rw_ext_t *>()->ro;
        }
        return v.get<const class_ro_t *>();
    }
    //获取方法
    const method_array_t methods() const {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            return v.get<class_rw_ext_t *>()->methods;
        } else {
            return method_array_t{v.get<const class_ro_t *>()->baseMethods()};
        }
    }

    //  获取属性数组
    const property_array_t properties() const {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            return v.get<class_rw_ext_t *>()->properties;
        } else {
            return property_array_t{v.get<const class_ro_t *>()->baseProperties};
        }
    }
    
    //协议
    const protocol_array_t protocols() const {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            return v.get<class_rw_ext_t *>()->protocols;
        } else {
            return protocol_array_t{v.get<const class_ro_t *>()->baseProtocols};
        }
    }
};

LLDB命令bits获取属性properties操作查看如下：

bits属性查看.png

• 【通过bits查看方法（methods）列表】

LLDB命令bits方法操作查看如下：

bits查看方法methods截图

• 【通过bits查看方法（ro）列表】

bits查看成员变量

不详细阐述问题描述了，直接总结吧

• 总结

通过bits存储信息，可以看出类的结构，类的数据存储，
成员变量：bits->data() .ro() . ivars
方法：bits->data() . methods
属性：bits->data() .properties
可以查看出类的结构和数据存储位置,通过偏移查看信息
其中结构体使用.调用，对象方法使用->调用。