8月底因为公司原因刚离职，在二线城市工作也很难找，boss上能投的公司不到10家。还是先不找了，9月份好好沉淀一下技术吧。
1.Objective-C的本质
Objective-C底层实现其实都是C\C++代码，可以通过如下命令将Objective-C代码转换为C\C++代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
2.OC对象的本质
新建一个Command-Line Tool 工程
点击进入NSObject.h头文件，可知NSObject的定义如下
@interface NSObject {
Class isa ;
}
将main.m转换为C\C++代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp
在C++代码中可以找到NSObject的实现
struct NSObject_IMPL {
Class isa;
};
Class是一个指向结构体的指针
typedef struct objc_class *Class;
下载objc4-818.2，在objc-runtime-new.h可以找到Objc2.0中objc_class的源码，截取部分代码如下
struct objc_class : objc_object {
// Class ISA;
Class superclass;
cache_t cache; // 方法缓存
class_data_bits_t bits; // 用于获取具体的类信息
class_rw_t *data() const {
return bits.data();
}
...
}
struct objc_object {
private:
isa_t isa;
}
...
objc_class 是一个继承自objc_object 的结构体,objc_object结构体中就只包含了一个isa_t类型的结构体isa，所以Objective-C的类也是对象，Objective-C对象和类都是基于C\C++的结构体实现的。
3.class_ro_t 与 class_rw_t
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 ro_or_rw_ext;
Class firstSubclass;
Class nextSiblingClass;
const class_ro_t *ro() const {
auto v = get_ro_or_rwe();
if (slowpath(v.is())) {
return v.get(&ro_or_rw_ext)->ro;
}
return v.get(&ro_or_rw_ext);
}
void set_ro(const class_ro_t *ro) {
auto v = get_ro_or_rwe();
if (v.is()) {
v.get(&ro_or_rw_ext)->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(&ro_or_rw_ext)->methods;
} else {
return method_array_t{v.get(&ro_or_rw_ext)->baseMethods()};
}
}
const property_array_t properties() const {// 属性列表
auto v = get_ro_or_rwe();
if (v.is()) {
return v.get(&ro_or_rw_ext)->properties;
} else {
return property_array_t{v.get(&ro_or_rw_ext)->baseProperties};
}
}
const protocol_array_t protocols() const {// 协议列表
auto v = get_ro_or_rwe();
if (v.is()) {
return v.get(&ro_or_rw_ext)->protocols;
} else {
return protocol_array_t{v.get(&ro_or_rw_ext)->baseProtocols};
}
}
...
}
class_rw_t存储了当前类在运行期的属性、方法以及遵循的协议，rw代表readwrite，是可读可写的。class_rw_t中包含 class_ro_t 并且为 const 类型。
class_ro_t 结构体定义
struct class_ro_t {
uint32_t flags;
uint32_t instanceStart;
uint32_t instanceSize;// instance对象占用的内存空间
#ifdef __LP64__
uint32_t reserved;
#endif
union {
const uint8_t * ivarLayout;
Class nonMetaclass;
};
explicit_atomic name;// 类名
// With ptrauth, this is signed if it points to a small list, but
// may be unsigned if it points to a big list.
void *baseMethodList;
protocol_list_t * baseProtocols;
const ivar_list_t * ivars;// 成员变量列表
const uint8_t * weakIvarLayout;
property_list_t *baseProperties;
}
class_ro_t存储了当前类在编译期就已经确定的属性、方法以及遵循的协议。ro代表read only。
在objc_class 初始化的过程中有一个realizeClassWithoutSwift方法证明了他们的关系, 源码如下
/***********************************************************************
* realizeClassWithoutSwift
* Performs first-time initialization on class cls,
* including allocating its read-write data.
* Does not perform any Swift-side initialization.
* Returns the real class structure for the class.
* Locking: runtimeLock must be write-locked by the caller
**********************************************************************/
static Class realizeClassWithoutSwift(Class cls, Class previously)
{
runtimeLock.assertLocked();
class_rw_t *rw;
Class supercls;
Class metacls;
if (!cls) return nil;
if (cls->isRealized()) {
validateAlreadyRealizedClass(cls);
return cls;
}
ASSERT(cls == remapClass(cls));
// fixme verify class is not in an un-dlopened part of the shared cache?
// 从mach-O中获取数据data，转换成class_ro_t
auto ro = (const class_ro_t *)cls->data();
auto isMeta = ro->flags & RO_META;// 元类判断
if (ro->flags & RO_FUTURE) {
// This was a future class. rw data is already allocated.
rw = cls->data();
ro = cls->data()->ro();
ASSERT(!isMeta);
cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
} else {
// Normal class. Allocate writeable class data.
rw = objc::zalloc();// 开辟空间
rw->set_ro(ro);// ro数据赋值给rw
rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
cls->setData(rw);// cls重新将rw作为其data复制
}
...
}
class_rw_t生成在运行时，在编译期间，class_ro_t结构体就已经确定，objc_class中的bits的data部分存放着该结构体的地址。在运行runtime的realizeClass 方法时，会生成class_rw_t结构体，class_ro_t会赋值给class_rw_t，并且更新data部分，换成class_rw_t结构体的地址此动作让运行时的对象有了对方法，属性和协议进行动态修改的可能。
整个运行时过程可以描述如下：
4.OC对象的分类
Objective-C中的对象主要分为3种，instance对象(实例对象)，class对象(类对象)，meta-class对象(元类对象)
4.1.实例对象
// instance对象，实例对象
NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];
实例对象就是通过类alloc出来的对象，每次调用alloc都会产生新的instance对象，并且占用不同的内存，instance对象在内存中存储的信息包括：isa指针和其他成员变量
4.2.类对象
// class对象，类对象
// class方法返回的一直是class对象，类对象
Class objectClass1 = [object1 class];
Class objectClass2 = [object2 class];
Class objectClass3 = object_getClass(object1);
Class objectClass4 = object_getClass(object2);
Class objectClass5 = [NSObject class];
objectClass1 ~ objectClass5都是NSObject的class对象（类对象）
它们是同一个对象。每个类在内存中有且只有一个class对象
class对象在内存中存储的信息主要包括
isa指针
superclass指针
类的属性信息（@property）、类的对象方法信息（instance method）
类的协议信息（protocol）、类的成员变量信息（ivar）
4.3.元类对象
// meta-class对象，元类对象
// 将类对象当做参数传入，获得元类对象
Class objectMetaClass = object_getClass(objectClass5);
objectMetaClass是NSObject的meta-class对象（元类对象）
每个类在内存中有且只有一个meta-class对象
meta-class对象和class对象的内存结构是一样的，但是用途不一样，在内存中存储的信息主要包括
isa指针
superclass指针
类的类方法信息（class method）
5.isa流程图
下图很好的描述了对象，类，元类之间的关系
总结
1.instance(实例对象)的isa指向class(类对象)
2.class(类对象)的isa指向meta-class(元类对象)
3.meta-class(元类对象)的isa指向Root meta-class(基类的元类对象)
4.class(类对象)的superclass指向父类的class(父类的类对象)
5.如果没有父类，superclass指针为nil
6.meta-class(元类对象)的superclass指向父类的meta-class(父类的元类对象)
7.基类的meta-class(元类对象)的superclass指向基类的class(类对象)
instance调用对象方法的轨迹
当调用对象方法时，通过instance的isa找到class，最后找到对象方法的实现进行调用，方法不存在，就通过superclass找父类
class调用类方法的轨迹
当调用类方法时，通过class的isa找到meta-class，最后找到类方法的实现进行调用，方法不存在，就通过superclass找父类
6.面试题
一个NSObject对象占用多少内存
系统分配了16个字节给NSObject对象（通过malloc_size函数获得）
但NSObject对象内部只使用了8个字节的空间（64bit环境下，可以通过class_getInstanceSize函数获得）
对象的isa指针指向哪里？
instance对象的isa指向class对象
class对象的isa指向meta-class对象
meta-class对象的isa指向基类的meta-class对象
OC的类信息存放在哪里？
对象方法、属性、成员变量、协议信息，存放在class对象中
类方法存放在meta-class对象中
成员变量的具体值，存放在instance对象