1、什么是类
iOS中所以的类继承NSObject，那么在底层NSObject的结构是怎么样的呢？
使用clang编译一下如下代码
#import <Foundation/Foundation.h>
@interface MCPerson : NSObject
@property (nonatomic,copy) NSString *name;
@end
@implementation MCPerson
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
MCPerson *p = [MCPerson alloc];
p.name = @"Hello";
}
return 0;
}
编译命令
clang -rewrite-objc main.m
生成文件main.cpp,搜索找到相关代码
struct objc_object {
Class _Nonnull isa __attribute__((deprecated));
};
struct objc_class : objc_object {...};//在objc-runtime-new源码中
typedef struct objc_object *id;//在objc-runtime-new源码中
typedef struct objc_class *Class;//结构体指针
typedef struct objc_object NSObject;//NSObject在底层是一个结构体里面包含isa指针
刚好证明OC中的万物皆对象原则，所以派生类都继承NSObject，在底层都继承objc_object结构体，简单来说，类的底层是继承objc_object，包含isa、superclass、cache、bits的结构体
2、类的结构
objc_class源码
struct objc_class : objc_object {
// Class ISA; //继承objc_object，所以有isa指针
Class superclass; //父类
cache_t cache; // 主要是缓存方法
class_data_bits_t bits; // 数据存储
class_rw_t *data() const {
return bits.data();
}
}
-
Class isa 指针
在对象初始化的时候通过isa将对象和类关联起来，而类也是一个对象，俗称类对象，类对象也是需要和元类关联起来的，所以类中也有isa指针。
isa走位图
Class superclass
这个很好理解，就是父类，一般来说，大部分类的父类都是NSObject，根元类的父类也是NSObject，NSObject的父类是nil。cache_t cache
struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
explicit_atomic<struct bucket_t *> _buckets;
explicit_atomic<mask_t> _mask;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
...
};
感觉这个成员变量的作用主要是用来缓存方法，留个疑问。
- class_data_bits_t bits
struct class_data_bits_t {
friend objc_class;
// Values are the FAST_ flags above.
uintptr_t bits;
class_rw_t* data() const {//核心，存储方法、属性、协议，可以动态修改
return (class_rw_t *)(bits & FAST_DATA_MASK);
}
const class_ro_t *safe_ro() {//存储成员变量，不可动态修改，类似readonly
class_rw_t *maybe_rw = data();
if (maybe_rw->flags & RW_REALIZED) {
// maybe_rw is rw
return maybe_rw->ro();
} else {
// maybe_rw is actually ro
return (class_ro_t *)maybe_rw;
}
}
void setData(class_rw_t *newData) {
bits.setData(newData);
}
bool hasCustomRR() const {
return !bits.getBit(FAST_HAS_DEFAULT_RR);
}
void setHasDefaultRR() {
bits.setBits(FAST_HAS_DEFAULT_RR);
}
void setHasCustomRR() {
bits.clearBits(FAST_HAS_DEFAULT_RR);
}
...
};
这里值得我们注意的是，objc_class 的 data()方法其实是返回的 bits 的 data() 方法，而通过这个 data() 方法，我们发现诸如类的字节对齐、ARC、元类等特性都有 data() 的出现，这间接说明 bits 属性其实是个大容器，有关于内存管理、C++ 析构等内容在其中有定义。
重点：
class_rw_t* data() //存储方法、属性、协议，可以动态修改
const class_ro_t *safe_ro() //存储成员变量，不可动态修改，类似readonly
3、类的方法、属性、协议分别存在哪里
struct class_rw_t {
const class_ro_t *ro() const {//ro
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};
}
}
...
};
4、如何读取类中的方法、属性、协议
属性、方法、协议都存在rw中，所以我们先需要获取rw
(lldb) p/x MCPerson.class
(Class) $0 = 0x0000000100002180 MCPerson
(lldb) p/x 0x0000000100002180 + 0x20
(long) $1 = 0x00000001000021a0
(lldb) p (class_data_bits_t *)$1
(class_data_bits_t *) $2 = 0x00000001000021a0
(lldb) p (class_rw_t*)$2->data()
(class_rw_t *) $3 = 0x000000010073b800//属性方法都在这里面
- 获取方法
(lldb) p $3->methods() //获取方法
(const method_array_t) $4 = {
list_array_tt<method_t, method_list_t> = {
= {
list = 0x00000001000020c0
arrayAndFlag = 4294975680
}
}
}
(lldb) p $4.list
(method_list_t *const) $5 = 0x00000001000020c0
(lldb) p *$5//打印指针的内容
(method_list_t) $6 = {
entsize_list_tt<method_t, method_list_t, 3> = {
entsizeAndFlags = 26
count = 3
first = {
name = ".cxx_destruct"
types = 0x0000000100000fa0 "v16@0:8"
imp = 0x0000000100000e50 (KCObjc`-[MCPerson .cxx_destruct] at main.m:16)
}
}
}
(lldb) p $6.get(0)// 获取第1个方法
(method_t) $7 = {
name = ".cxx_destruct"
types = 0x0000000100000fa0 "v16@0:8"
imp = 0x0000000100000e50 (KCObjc`-[MCPerson .cxx_destruct] at main.m:16)
(lldb) p $6.get(1)
(method_t) $8 = {
name = "name"
types = 0x0000000100000f8d "@16@0:8"
imp = 0x0000000100000df0 (KCObjc`-[MCPerson name] at main.m:13)
}
(lldb) p $6.get(2)
(method_t) $9 = {
name = "setName:"
types = 0x0000000100000f95 "v24@0:8@16"
imp = 0x0000000100000e20 (KCObjc`-[MCPerson setName:] at main.m:13)
}
- 获取属性
(lldb) p $3->properties()//获取属性
(const property_array_t) $10 = {
list_array_tt<property_t, property_list_t> = {
= {
list = 0x0000000100002138
arrayAndFlag = 4294975800
}
}
}
(lldb) p $10.list
(property_list_t *const) $11 = 0x0000000100002138
(lldb) p *$11
(property_list_t) $12 = {
entsize_list_tt<property_t, property_list_t, 0> = {
entsizeAndFlags = 16
count = 1
first = (name = "name", attributes = "T@\"NSString\",C,N,V_name")
}
}
(lldb) p $12->get(0)
(property_t) $13 = (name = "name", attributes = "T@\"NSString\",C,N,V_name")
Fix-it applied, fixed expression was:
$12.get(0)
(lldb) p $12.get(0)
(property_t) $14 = (name = "name", attributes = "T@\"NSString\",C,N,V_name")
- 获取协议
(lldb) p $3->protocols()//获取协议
(const protocol_array_t) $15 = {
list_array_tt<unsigned long, protocol_list_t> = {
= {
list = 0x0000000000000000//全是0，表明没有，如果有跟上面的步骤一致
arrayAndFlag = 0
}
}
}
4、类的成员变量存在哪里
拓展，成员变量没有存在rw中，存在ro中
5、总结
万物皆对象：类的本质就是对象，类也是对象（类对象）
类在 class_rw_t 结构中存储了编译时确定的属性、方法和协议等内容。
实例方法存放在类中，类方法存在元类中
