讲述 objective-c 2.0 对 class 的定义，类、元类的关系，一些面试题，并且对 block 简单说明。
网上很多文章对 class 的定义还是 OC 1.0 的，因此自己写一篇记录一下。
iOS 运行时代码 objc4 的下载地址：
https://opensource.apple.com/tarballs/objc4/
打开源代码，Xcode 同时按 cmd + shift + o，输入 Class 可以搜到相关定义。
1、简化定义
// Class
typedef struct objc_class *Class;
// id
typedef struct objc_object *id;
// 类
struct objc_class : objc_object {
// 省略部分成员变量以及方法...
}
// 对象
struct objc_object {
// 省略部分成员变量以及方法...
}
// Object
@interface Object {
Class isa;
}
@end
// NSObject
@interface NSObject <NSObject> {
Class isa;
}
可见，类和对象是结构体。
类也是对象，因为对象和类都是结构体 objc_object。
2、详细定义
2.1 对象
结构体 objc_object：
struct objc_object {
private:
isa_t isa;
// 省略部分成员变量以及方法...
}
联合体 isa_t：
union isa_t {
Class cls;
uintptr_t bits;
// 省略部分成员变量以及方法...
};
对象有个 isa_t ，isa_t 有个 Class 指向对象的类。
类也是对象，类的 isa_t 的 Class 指向元类。
元类保存类方法，类保存实例方法。
2.2 类
结构体 objc_class：
struct objc_class : objc_object {
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 有类的方法和属性列表。
class_rw_t *data() {
return bits.data();
}
// 省略部分成员变量以及方法...
}
superclass 是父类，
cache_t 是方法缓存，
class_data_bits_t 包含 class_rw_t，
class_rw_t 里面有类的方法和属性列表。
结构体 class_rw_t：
struct class_rw_t {
method_array_t methods;
property_array_t properties;
protocol_array_t protocols;
const class_ro_t *ro;
Class firstSubclass;
Class nextSiblingClass;
char *demangledName;
// 省略部分成员变量以及方法...
};
method_array_t 是个类，保存方法列表，
property_array_t 保存属性列表，
protocol_array_t 保存协议列表。
objc_object 可以简单理解为，有个 isa 指向对象的类，
objc_class 比 objc_object 多了方法列表、属性列表。
然后类、元类也是对象。
3、对象、类、元类的关系
类、元类，也是对象，他们的关系如下图所示：
Root class 是 NSObject。
- 对于 instance，没有 superclass 线，isa 都指向自己的类。
- 对于 class，superclass 指向父类，isa 指向元类。
- 对于 meta，superclass 指向父类，isa 指向同一个元类，即 NSObject meta class。
- NSObject 没有父类，所以 superclass 指向 nil。
- NSObject meta class 的 isa 指向 NSObject 类，形成闭环。
为什么所有元类的 isa 都指向 NSObject meta class？
为什么 NSObject meta class 的 superclass 要指向 NSObject？
有没有大神解答一下😑。
查找对象方法时，根据对象的 isa 找到对象的类，如果子类没有找到方法，就通过 superclass 找到父类，在父类查找方法。
查找类方法时，根据类的 isa 找到元类，如果子元类没有找到，就通过 superclass 找到父元类，在父元类查找方法。
如果根元类，即 NSObject meta class 也没找到，就会去 superclass，也就是 NSObject 类查找。
如果想深入了解，可以看这篇文章：《神经病院Objective-C Runtime入院第一天——isa和Class》。
4、一些题目
4.1
类调用实例方法，是否会崩溃？
// 分类
@interface NSObject (Test)
+ (void)ioo;
@end
@implementation NSObject (Test)
- (void)ioo {
NSLog(@"%@", NSStringFromSelector(_cmd));
}
@end
测试用例：
- (void)test1 {
[NSObject ioo]; // 1、
[NSString ioo]; // 2、
}
1 和 2，哪个会崩溃？
答案是都不会崩溃。
对于 [NSObject ioo] ，先在元类 NSObject meta class 里面找不到 ioo 方法，然后在元类的父类 NSObject class 里找到了。元类 NSObject meta class 的 superclass 指向类 NSObject class 。
对于 [NSString ioo]，先在 NSString meta class 里面找不到，然后在 superclass 指向的 NSObject meta class 里也找不到，最后在 NSObject meta class 的 superclass 指向的 NSObject class 里找到了。
4.2
下面的代码是否会崩溃
// 分类
@interface NSString (Test)
+ (void)sioo;
@end
@implementation NSString (Test)
- (void)sioo {
NSLog(@"%@", NSStringFromSelector(_cmd));
}
@end
- (void)test2 {
[NSString ioo]; // 1、
[NSString sioo]; // 2、
}
1 不会崩溃，2 会崩溃。
对于 [NSString sioo]，寻找的过程是 NSString meta class、NSObject meta class、NSObject，而方法 sioo 是定义在 NSString 里面，所以崩溃了。
另外，假设只声明但没有实现方法 - (void)fun，
对于 [[NSObject new] fun]，在 NSObject 里找不到，而 NSObject 的父类是 nil，因此崩溃了。
4.3
下面代码输出什么
- (void)test3 {
BOOL b1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];
BOOL b2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
BOOL b3 = [(id)[Son class] isKindOfClass:[Son class]];
BOOL b4 = [(id)[Son class] isMemberOfClass:[Son class]];
NSLog(@"%d %d %d %d", b1, b2, b3, b4);
BOOL b5 = [[Son new] isKindOfClass:[Son class]];
BOOL b6 = [[Son new] isMemberOfClass:[Son class]];
NSLog(@"%d %d", b5, b6);
BOOL b7 = class_isMetaClass([Son class]); // 要 #import <objc/runtime.h>
BOOL b8 = [Son new].class == [Son class];
BOOL b9 = class_isMetaClass([[Son class] class]);
NSLog(@"%d %d %d", b7, b8, b9);
}
b1-4 输出 1 0 0 0，
b5-6 输出 1 1，
b7-9 输出 0 1 0。
先看 class 方法：
+ (Class)class {
return self;
}
- (Class)class {
return object_getClass(self);
}
Class object_getClass(id obj)
{
if (obj) return obj->getIsa();
else return Nil;
}
方法 object_getClass 是获取对象的 isa 指向的 class。
类和对象的 class 方法都返回类，不是元类。
类的 class 方法返回 self，对象的返回所属类。
举个栗子：
po [Son class]
po [[[[Son class] class] class] class]
上面都是输出 Son，不管调用多少次 class，返回的都是 self
然后看下 isMemberOfClass 方法：
+ (BOOL)isMemberOfClass:(Class)cls {
return object_getClass((id)self) == cls;
}
- (BOOL)isMemberOfClass:(Class)cls {
return [self class] == cls;
}
- (Class)class {
return object_getClass(self);
}
Class object_getClass(id obj)
{
if (obj) return obj->getIsa();
else return Nil;
}
方法 object_getClass 是获取对象的 isa 指向的 class，如果传入的参数是类对象，获取的就是元类了。
方法 isMemberOfClass 会取一次 isa 指向的类，然后进行比较。
如果是对象调用 isMemberOfClass，就是类与类比较。
如果是类调用 isMemberOfClass，就是元类与类比较。
举个栗子：
[(id)[A class] isMemberOfClass:[B class]];
上面代码是 A meta class，与 B class 进行比较，
而不是 A class 与 B class 比较。
最后看下 isKindOfClass ：
+ (BOOL)isKindOfClass:(Class)cls {
for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
if (tcls == cls) return YES;
}
return NO;
}
- (BOOL)isKindOfClass:(Class)cls {
for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
if (tcls == cls) return YES;
}
return NO;
}
- (Class)class {
return object_getClass(self);
}
Class object_getClass(id obj)
{
if (obj) return obj->getIsa();
else return Nil;
}
可见 isKindOfClass 就是 isMemberOfClass 的循环版，会通过 superclass 沿着继承链进行判断。
如果是对象调用 isMemberOfClass，会沿着 class 继承链判断。
如果是类调用 isMemberOfClass，会沿着 meta class 继承链判断。
需要注意的是，NSObject meta class 的 superclass 是 NSObject class，isa 指向自己。
NSObject class 的 superclass 是 nil，isa 指向 NSObject meta class。
对于
BOOL b1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]，
先是 NSObject meta class 与 NSObject class 比较，
然后是 NSObject class 与 NSObject class 比较，所以结果是 1。
总结一下：
- (void)test3 {
// 类和对象的 class 方法会返回类，不是元类。
// 类的 class 方法返回 self，对象的返回所属类。
// isMemberOfClass 会取 isa 指向的类，与参数的类就行比较
// 如果是对象调用 isMemberOfClass，就是类与类比较
// 如果是类调用 isMemberOfClass，就是元类与类比较
// isKindOfClass 会通过 superclass 沿着继承链循环判断
BOOL b1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]; // 1，循环到 NSObject == NSObject
BOOL b2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]]; // 0，NSObject meta != NSObject
BOOL b3 = [(id)[Son class] isKindOfClass:[Son class]]; // 0，从 Son meta class 循环到 NSObject 到 nil，都 != Son
BOOL b4 = [(id)[Son class] isMemberOfClass:[Son class]]; // 0，Son meta != Son
b3 = [Son isKindOfClass:[Son class]]; // 0，和上面的两句是一样的
b4 = [Son isMemberOfClass:[Son class]]; // 0，Son meta != Son
NSLog(@"%d %d %d %d", b1, b2, b3, b4);// 1 0 0 0
BOOL b5 = [[Son new] isKindOfClass:[Son class]]; // 1
BOOL b6 = [[Son new] isMemberOfClass:[Son class]]; // 1，Son == Son
NSLog(@"%d %d", b5, b6); // 1 1
BOOL b7 = class_isMetaClass([Son class]); // 0，要 #import <objc/runtime.h>
BOOL b8 = [Son new].class == [Son class]; // 1，Son == Son
BOOL b9 = class_isMetaClass([[Son class] class]); // 0，[[Son class] class] == Son
NSLog(@"%d %d %d", b7, b8, b9);// 0 1 0
}
5、Block
最后简单说一下 block。block 也是对象。
定义一个继承自 NSObject 的 Test 类，有个 test 方法：
@implementation Test
- (void)test {
void (^blc)(void) = ^ {
printf("哈哈哈");
};
blc();
}
@end
代码转换后， block 语法转换的函数：
// block 的函数，参数是一个 block 指针
static void __Test__test_block_func_0(struct __Test__test_block_impl_0 *__cself) {
printf("哈哈哈");
}
block 转换成结构体：
// 自定义 block 的结构体
struct __Test__test_block_impl_0 {
struct __block_impl impl; // block 的基本定义
struct __Test__test_block_desc_0* Desc; // block 的数据
// 构造函数。
// fp 是 block 的函数的指针，desc 是 block 的数据。
__Test__test_block_impl_0(void *fp, struct __Test__test_block_desc_0 *desc, int flags=0) {
// 省略部分代码
}
};
再看 block 的基本定义：
// block 的基本定义
struct __block_impl {
void *isa; // block 的类
int Flags;
int Reserved;
void *FuncPtr; // 指向 block 的函数
};
里面有个 isa 指针，指向 block 的类，可以是堆、栈、全局 block。
打印输出 block 的继承链：
(lldb) po [blc class]
__NSGlobalBlock__
(lldb) po [blc superclass]
__NSGlobalBlock
(lldb) po [[blc superclass] superclass]
NSBlock
(lldb) po [[[blc superclass] superclass] superclass]
NSObject
(lldb) po [[[[blc superclass] superclass] superclass] superclass]
nil
具体可以看我的另一篇文章 笔记-《Objective-C高级编程 iOS与OS X多线程和内存管理》，在 2.3 章节记录 Blocks 的实现。
如有错误，欢迎指正。
