iOS-底层分析之类的结构分析

类的结构分析

本文主要分析iOS中的类以及类的结构，下面我们通过一个例子来探索类的结构

我们定义一个WPerson类

@interface WPerson : NSObject

@property (nonatomic, copy) NSString *nickName;
@property (nonatomic, strong) NSString *name;
-(void)say666;
+(void)sayNB;
@end

@implementation WPerson

-(void)say666
{
    NSLog(@"~~666~~");
}
+(void)sayNB
{
    NSLog(@"~~NB~~");
}
@end

我们通过Clang命令将这个类编译成.cpp文件

//main.m 是要编译的文件名，
//main.cpp 是编译结果的输出文件名
clang -rewrite-objc main.m -o main.cpp

我们在编译结果的文件中找到WPerson:

struct WPerson_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    NSString *_nickName;
    NSString *_name;
};

我们看到WPerson类被编译成了一个结构体，并且结构体中包含了我们声明的两个属性，并且在编译的过程中自动生成了get和set方法

static NSString * _I_WPerson_nickName(WPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_WPerson$_nickName)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_WPerson_setNickName_(WPerson * self, SEL _cmd, NSString *nickName) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct WPerson, _nickName), (id)nickName, 0, 1); }

static NSString * _I_WPerson_name(WPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_WPerson$_name)); }
static void _I_WPerson_setName_(WPerson * self, SEL _cmd, NSString *name) { (*(NSString **)((char *)self + OBJC_IVAR_$_WPerson$_name)) = name; }

所以我们可以得出结论：

所有继承自NSObject的子类都会被编译成一个结构体，也就是说类实际是一种结构体类型

objc_class源码探索

我们再看一下Class类型的定义，我们在.cpp的源码中找到：typedef struct objc_class *Class; 我们知道了Class是objc_class类型的结构，接下来我们在objc源码中探索一下objc_class的源码

这里使用的是objc4-781版本的源码，下载地址objc源码

我们在源码中的objc-runtime-new.h中找到了objc_class的定义：

struct objc_class : objc_object {
    // Class ISA;
    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 *data() const {
        return bits.data();
    }
    
    //这里的其他方法以及属性已经略去
}

我们看到objc_class继承自objc_object，我们再来看看objc_object的源码：

struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

objc_class有以下四个属性：

isa
superclass
cache （这里不作探索，后面会补上这部分内容）
bits（这里不作探索，后面会补上这部分内容）

isa

我们在iOS-底层分析之isa一文中已经知道对象的isa指向的是该对象所属的类，那么类结构体的isa指针又指向哪里呢？接下来我们看一张非常经典的isa走位图：

isa流程图

我们可以看出，类的isa指向了该类的元类

superclass

顾名思义，superclass是指向父类的指针，如果继承自NSObject，那么superclass指向NSObject

类的方法以，属性，成员变量的查找

我们知道类实际上是方法，属性的几个集合，那么在类的结构中，这些属性和方法是怎么存储的呢？

在开始之前，我们需要先了解什么是内存偏移

内存偏移

我们声明两个变量，并打印这两个变量的地址

int a = 10;
int b = 10;
    
NSLog(@"~~~ %d----%p",a,&a);
NSLog(@"~~~ %d----%p",b,&b);

打印的结果如下

[29463:603046] ~~~ 10----0x7ffeefbff5b0
[29463:603046] ~~~ 10----0x7ffeefbff5b4

我们看到打印的结果，a和b的地址相差四个字节，正好是int类型所占的存储空间，实际上在创建对象的时候，内存的分配也是符合偏移的原则的，我们可以根据对象的首地址加上相应属性的偏移量去读取对应的属性

类的属性存储探索

我们接下来通过一顿骚操作（其实就是lldb的调试），来找到类中属性的存储位置：

p/x WPerson.class 打印WPerson类的首地址
```
(Class) $0 = 0x0000000100002210 WPerson
```

x/4gx 0x0000000100002210 打印出WPerson类的内存信息

0x100002210: 0x00000001000021e8 0x0000000100334140
0x100002220: 0x000000010032e410 0x0000802400000000

p (class_data_bits_t *)0x100002230 通过内存地址的偏移32字节打印出class中的bits
```
(class_data_bits_t *) $1 = 0x0000000100002230
```

p *$1->data() 获取bits的data

(class_rw_t) $3 = {
  flags = 2148007936
  witness = 0
  ro_or_rw_ext = {
    std::__1::atomic = 4294975624
  }
  firstSubclass = nil
  nextSiblingClass = NSUUID
}

p $3.properties() 调用properties方法

(const property_array_t) $4 = {
  list_array_tt = {
     = {
      list = 0x0000000100002198
      arrayAndFlag = 4294975896
    }
  }
}

p $4.list 读取属性列表

(property_list_t *const) $5 = 0x0000000100002198

p *$5 获取属性列表的首地址

(property_list_t) $6 = {
  entsize_list_tt = {
    entsizeAndFlags = 16
    count = 2
    first = (name = "nickName", attributes = "T@\"NSString\",C,N,V_nickName")
  }
}

p $6.get(0) 获取属性列表的第一条数据

(property_t) $7 = (name = "nickName", attributes = "T@\"NSString\",C,N,V_nickName")

p $6.get(1) 获取属性列表的第二条数据

(property_t) $8 = (name = "name", attributes = "T@\"NSString\",&,N,V_name")

通过这种方式，我们可以获取到类的属性列表，我们也知道了，类的属性实际存储在一个class_rw_t类型的结构体中，关于class_rw_t的定义，我们可以在objc源码中找到（部分代码已省略）

struct class_rw_t {
public:
    void setFlags(uint32_t set)
    {
        __c11_atomic_fetch_or((_Atomic(uint32_t) *)&flags, set, __ATOMIC_RELAXED);
    }

    void clearFlags(uint32_t clear) 
    {
        __c11_atomic_fetch_and((_Atomic(uint32_t) *)&flags, ~clear, __ATOMIC_RELAXED);
    }

    // set and clear must not overlap
    void changeFlags(uint32_t set, uint32_t clear) 
    {
        ASSERT((set & clear) == 0);

        uint32_t oldf, newf;
        do {
            oldf = flags;
            newf = (oldf | set) & ~clear;
        } while (!OSAtomicCompareAndSwap32Barrier(oldf, newf, (volatile int32_t *)&flags));
    }

    class_rw_ext_t *ext() const {
        return get_ro_or_rwe().dyn_cast();
    }

    class_rw_ext_t *extAllocIfNeeded() {
        auto v = get_ro_or_rwe();
        if (fastpath(v.is())) {
            return v.get();
        } else {
            return extAlloc(v.get());
        }
    }

    class_rw_ext_t *deepCopy(const class_ro_t *ro) {
        return extAlloc(ro, true);
    }

    const class_ro_t *ro() const {
        auto v = get_ro_or_rwe();
        if (slowpath(v.is())) {
            return v.get()->ro;
        }
        return v.get();
    }

    void set_ro(const class_ro_t *ro) {
        auto v = get_ro_or_rwe();
        if (v.is()) {
            v.get()->ro = ro;
        } else {
            set_ro_or_rwe(ro);
        }
    }

    const method_array_t methods() const {
        auto v = get_ro_or_rwe();
        if (v.is()) {
            return v.get()->methods;
        } else {
            return method_array_t{v.get()->baseMethods()};
        }
    }

    const property_array_t properties() const {
        auto v = get_ro_or_rwe();
        if (v.is()) {
            return v.get()->properties;
        } else {
            return property_array_t{v.get()->baseProperties};
        }
    }

    const protocol_array_t protocols() const {
        auto v = get_ro_or_rwe();
        if (v.is()) {
            return v.get()->protocols;
        } else {
            return protocol_array_t{v.get()->baseProtocols};
        }
    }
};

我们看到这里不仅存储了properties属性，同时还存储了类的方法列表methods，和协议列表protocols，但是我们通过探索发现两个问题：

属性列表中并没有存储类的成员变量
方法列表中并未存储类方法（+(void)sayNB;）

成员变量的存储

我们在class_rw_t结构中发现了有一个返回值类型为class_ro_t的ro方法，通过进一步探索发现成员变量实际存储在class_ro_t的ivars中（探索过程同上）

类方法的存储

我们通过上面的方法探索发现类方法并未存储在methods()方法中，我们先说结论：

类方法实际存储在元类的方法列表中

我们可以通过Class的isa指针来验证这一结论

(lldb) x/4gx WPerson.class
0x100002248: 0x0000000100002220 0x0000000100334140
0x100002258: 0x000000010032e410 0x0000802400000000
(lldb) p/x 0x0000000100002220 & 0x0000000ffffffff8ULL
(unsigned long long) $1 = 0x0000000100002220

(lldb) p/x (class_data_bits_t *)0x0000000100002240
(class_data_bits_t *) $4 = 0x0000000100002240
(lldb) p $4->data()
(class_rw_t *) $5 = 0x0000000101110110
(lldb) p *$5
(class_rw_t) $6 = {
  flags = 2684878849
  witness = 1
  ro_or_rw_ext = {
    std::__1::atomic = 4294975552
  }
  firstSubclass = nil
  nextSiblingClass = 0x00007fff8e608cd8
}
(lldb) p $6.methods()
(const method_array_t) $7 = {
  list_array_tt = {
     = {
      list = 0x0000000100002088
      arrayAndFlag = 4294975624
    }
  }
}
(lldb) p $7.list
(method_list_t *const) $8 = 0x0000000100002088
(lldb) p *$8
(method_list_t) $9 = {
  entsize_list_tt = {
    entsizeAndFlags = 26
    count = 1
    first = {
      name = "sayNB"
      types = 0x0000000100000f7f "v16@0:8"
      imp = 0x0000000100000ce0 (KCObjc`+[WPerson sayNB])
    }
  }
}
(lldb) p $9.get(0)
(method_t) $10 = {
  name = "sayNB"
  types = 0x0000000100000f7f "v16@0:8"
  imp = 0x0000000100000ce0 (KCObjc`+[WPerson sayNB])
}

通过这一顿骚操作，我们在WPerson的isa所指向的类中找到了sayNB方法