iOS底层原理：类&类的结构分析
在分析类的结构之前，我们需要先搞清楚类的内存分布情况。
类的内存分布
首先创建一个Person类：
// Person 类
@interface Person : NSObject
- (void)sayHello;
+ (void)sayHi;
@end
@implementation Person
- (void)sayHello {
NSLog(@"Say Hello");
}
+ (void)sayHi {
NSLog(@"Say Hi");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
Person *person = [[Person alloc] init];
NSLog(@"%@",person);
}
return 0;
}
类的lldb调试分析
通过上图中可以看出 0x00000001000012e8 和 0x00000001000012c0 为什么打印出的结果都是 Person 呢？这个东西其实就是元类。
那么什么是元类呢？
元类
每一个对象都对应一个类。
Person类就是person对象的类，换句话说就是person对象的isa指针指向Person对应的结构体；[Person class]也是对象，描述它的类就是元类，换句话说[Person class]对象的isa指向的就是元类元类的定义和创建都是由编译器自动完成。
元类保存了类方法的列表。当一个类方法被调用时，元类会首先查找它本身是否有该类的方法的实现，如果没有则该类会向它的父类查找该方法，知道一直找到继承链的头。
元类分析
元类跟踪
从上图中我们可以看到，我们通过isa可以一直找到NSObject类。通过 person对象的isa指针可以找到Person类，通过Person的isa指针可以找到元类Person，而通过元类Person的isa指针又可以找元类Person的元类NSObject，通过元类NSObject的isa指针找到的还是NSObject，其实这个时候的NSObject叫做根元类
但是NSObject的类和 NSObject.class 的指针地址不一样呢？是NSObject类会在内存中存在多份吗？
我们通过如下代码打印来看下：
void getClassInfo() {
Class class1 = [Person class];
Class class2 = [Person alloc].class;
Class class3 = object_getClass([Person alloc]);
NSLog(@"\n%p\n%p\n%p\n",class1,class2,class3);
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
getClassInfo();
}
return 0;
}
输出结果如下：
2020-09-15 20:49:21.406345+0800 ObjectAnalysis[34085:811450]
0x1000012f0
0x1000012f0
0x1000012f0
Program ended with exit code: 0
可以看出其实类对象在整个内存中只有一份。
因此我们可以得出一个著名的isa的走位图。
isa的走位图&继承图
走位图
isa查找流程
-
示例对象的isa指针类对象 -
类对象的isa指向元类对象 -
元类对象的isa指向根元类 -
根元类的isa指向它自己本身，从而形成了闭环
继承关系
类对象的继承关系
-
类继承于它的父类 -
父类继承它的父类
... - 直到找到
根类，也就是NSObject -
NSObject则继承于nil，这也就是所有的根源，即无中生有
元类的继承关系
-
子类的元类继承与父类的元类 -
父类的元类继承它的父类的元类
... - 直到找到
根元类 - 而
根元类则是继承于NSObject
tips:实例对象是没有继承关系的，只有类才有继承关系
对象的本质
对象的本质其实就是结构体，而编译到底层都是继承自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_object
struct objc_object {
private:
isa_t isa;
public:
// ISA() assumes this is NOT a tagged pointer object
Class ISA();
// rawISA() assumes this is NOT a tagged pointer object or a non pointer ISA
Class rawISA();
// getIsa() allows this to be a tagged pointer object
Class getIsa();
// 代码过多，自动省略
...
};
通过源码可以看出 objc_class 其实就是继承自 objc_object。
所以我们可以看出所有的 对象、类和元类都有isa指针，是因为都继承自 objc_object，而 objc_object中有个私有变量isa。
objc_object、objc_class、isa、object、NSObject的关系如下图所示：
关系图
我们接下来重点就是分析类的结构了
类的结构分析
再开始前，先分析下objc_class的结构图
objc_class
- isa 是指向元类的指针
- superclass 是指向当前类的父类
- cache 是用于缓存方法的，用于加速方法的调用
- bits 是存储类的方法、属性、协议等信息的地方
一般我们获取到bits，然后才能获取到我们需要的信息，那么我们就需要进行32位指针的偏移，为什么是32位指针的偏移，请看下面的代码段分析：
struct objc_class : objc_object {
// Class ISA; // 指针占 8 字节
Class superclass; // 指针占 8 字节
cache_t cache; // 占 16 字节，具体分析，看cache_t 结构体的分析
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
class_rw_t *data() const {
return bits.data();
}
// 代码过多，自动省略
...
};
// mask_t 的定义
#if __LP64__
typedef uint32_t mask_t; // x86_64 & arm64 asm are less efficient with 16-bits
#else
typedef uint16_t mask_t;
#endif
// 结构体指针字节大小，看里面的成员变量，而大部分都是 static 和方法都不存在结构体里面
struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
explicit_atomic<struct bucket_t *> _buckets; // 结构体指针 8 字节
explicit_atomic<mask_t> _mask; // uint32_t 占 4 字节
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
#if __LP64__
uint16_t _flags; // 占 2 字节
#endif
uint16_t _occupied; // 占 2 字节
// 方法代码过多，自动省略
...
};
class_data_bits_t
在objc_class结构体中的注释中已经写到class_data_bits_t相当于class_rw_t指针加上rr/alloc的标志。
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
而在class_data_bits_t结构体中为我们提供了一个用于返回其中的class_rw_t *的方法
struct class_data_bits_t {
friend objc_class;
// Values are the FAST_ flags above.
uintptr_t bits;
// 代码过多，自动省略
...
public:
class_rw_t* data() const {
return (class_rw_t *)(bits & FAST_DATA_MASK);
}
// 代码过多，自动省略
...
};
class_rw_t
struct class_rw_t {
// Be warned that Symbolication knows the layout of this structure.
uint32_t flags;
uint16_t witness;
#if SUPPORT_INDEXED_ISA
uint16_t index;
#endif
explicit_atomic<uintptr_t> ro_or_rw_ext;
Class firstSubclass;
Class nextSiblingClass;
// 省略过多的代码
...
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};
}
}
};
可以看出，我们可以通过class_rw_t结构体中提供的methods()、properties()、protocols()获取到对应的方法、属性和协议。
那么接下来我们通过lldb调试来查找对应的class_data_bist_t bits，查看相应的信息。
class_rw_t
当我们获取到class_rw_t结构体信息后，接下来想要获取到方法、属性或者协议，就需要通过调用其提供的方法来进行获取。
属性列表 properties()
属性信息
- 1、通过
properties()可以获取到对应的属性列表 - 2、通过get方法访问第一个属性，可以发现是我们定义的
name属性
【error】但是尝试去获取第二个属性的时候，发现数组越界了，这是为什么呢？我们不是还定义了一个hobby吗？
由此引出成员变量、实例变量和属性的区别
成员变量/实例变量/属性
成员变量： Member Variable declarations
类： Class (description/template for an object)
实例： Instance (manifestation of a class)
消息： Message (sent to object to make it act)
方法： Method (code invoked by a Message)
实例变量： Instance Variable (object-specific storage)
超类/子类： Superclass/Subclass (Inheritance)
协议： Protocol (non-class-specific methods)
从上面的解释，可以看出，实例是针对类而言的，。实例是指类的声明，由此推理，实例变量是指由类声明的对象。
而属性和成员变量的区别在于有无setter、getter方法。
方法列表 methods()
我们还是先通过lldb调试来查找方法列表。
methods
通过上图的lldb调试过程，我们可以发现：
-
method_list_t中有方法的总个数count=4 - 会优先存储我们定义的实例方法
- 会有一个隐藏的析构函数
.cxx_destruct，实现ARC下自动释放内存的工作 -
setter、getter方法的存储
其实探索到这里，发现我们还遗留了两个问题：
1、成员变量的存储
2、类方法的存储
成员变量的存储
其实通过objc_class的源码，我们可以知道里面其实还有个ro方法，会返回一个class_ro_t的结构体的信息。打印信息如下：
ivars
在class_ro_t结构体中其实有很多的成员变量和方法，其实class_rw_t中的ro，在类的编译期就已经确定了属性、方法以及要遵循的协议，objc_class中的bits中的data部分存放了ro信息。而在runtime运行之后，准确的说是在运行runtime的realizeClass方法时，会生成class_rw_t结构体，该结构体包含了class_ro_t，并且更新了data部分。换成了class_rw_t结构体的地址。
由上图的llbd打印出的ivars信息中，可以看到，我们生命的属性，也会在ivars中生成一个 _name的成员变量。这也就是我们为什么可以通过 _name和self.name来访问属性的原因了。
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;
// This field exists only when RO_HAS_SWIFT_INITIALIZER is set.
_objc_swiftMetadataInitializer __ptrauth_objc_method_list_imp _swiftMetadataInitializer_NEVER_USE[0];
_objc_swiftMetadataInitializer swiftMetadataInitializer() const {
if (flags & RO_HAS_SWIFT_INITIALIZER) {
return _swiftMetadataInitializer_NEVER_USE[0];
} else {
return nil;
}
}
method_list_t *baseMethods() const {
return baseMethodList;
}
class_ro_t *duplicate() const {
if (flags & RO_HAS_SWIFT_INITIALIZER) {
size_t size = sizeof(*this) + sizeof(_swiftMetadataInitializer_NEVER_USE[0]);
class_ro_t *ro = (class_ro_t *)memdup(this, size);
ro->_swiftMetadataInitializer_NEVER_USE[0] = this->_swiftMetadataInitializer_NEVER_USE[0];
return ro;
} else {
size_t size = sizeof(*this);
class_ro_t *ro = (class_ro_t *)memdup(this, size);
return ro;
}
}
};
类方法的存储
其实我们从上面的isa走位图中就可以知道一点，所有的实例对象的isa都是指向其元类的，那么我们是否可以查看其元类中的方法列表。下面我们通过lldb调试来看一下。
类方法
所以可以看出对象中的类方法都是存储在其元类中的。
