一. super底层实现
先看结论：
[super message]的底层实现
① 消息接收者仍然是子类对象
② 从父类开始查找方法的实现
MJStudent继承于MJPerson，MJPerson继承于NSObject，在MJStudent写如下代码：
- (instancetype)init
{
if (self = [super init]) {
NSLog(@"[self class] = %@", [self class]); // MJStudent
NSLog(@"[self superclass] = %@", [self superclass]); // MJPerson
NSLog(@"--------------------------------");
// objc_msgSendSuper({self, [MJPerson class]}, @selector(class));
NSLog(@"[super class] = %@", [super class]); // MJStudent
NSLog(@"[super superclass] = %@", [super superclass]); // MJPerson
}
return self;
}
打印：
[self class] = MJStudent
[self superclass] = MJPerson
--------------------------------
[super class] = MJStudent
[super superclass] = MJPerson
前两行我们比较容易理解，第三行第四行为什么和我们想的不一样呢？
为了弄明白原因，在MJPerson.m里面写如下代码：
- (void)run
{
NSLog(@"%@",self);
}
在MJStudent.m里面写如下代码，然后将代码转成C++代码：
- (void)run
{
//super调用的receiver仍然是MJStudent对象
[super run];
}
C++代码如下：
static void _I_MJStudent_run(MJStudent * self, SEL _cmd) {
((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("MJStudent"))}, sel_registerName("run"));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_MJStudent_69ea3c_mi_0);
}
[super run]的C++实现如下：
((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("MJStudent"))}, sel_registerName("run"));
可以看出，objc_msgSendSuper函数传入两个参数，一个是结构体，一个是sel_registerName("run")，在objc4里面搜索“objc_super {”，结果：
struct objc_super {
__unsafe_unretained _Nonnull id receiver; // 消息接收者
__unsafe_unretained _Nonnull Class super_class; // 消息接收者的父类
};
可以看出objc_super结构体传入两个参数，一个是消息接收者，一个是消息接收者的父类，为了更容易观察，将上面代码简化，如下：
struct objc_super arg = {self, [MJPerson class]};
objc_msgSendSuper(arg, @selector(run));
在objc4里面搜索“ objc_msgSendSuper(”,结果：
/**
* Sends a message with a simple return value to the superclass of an instance of a class.
*
* @param super A pointer to an \c objc_super data structure. Pass values identifying the
* context the message was sent to, including the instance of the class that is to receive the
* message and the superclass at which to start searching for the method implementation.
* @param op A pointer of type SEL. Pass the selector of the method that will handle the message.
* @param ...
* A variable argument list containing the arguments to the method.
*
* @return The return value of the method identified by \e op.
*
* @see objc_msgSend
*/
OBJC_EXPORT id _Nullable
objc_msgSendSuper(struct objc_super * _Nonnull super, SEL _Nonnull op, ...)
OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
虽然没有具体的实现，但是有两句核心注释：
包括消息接收者和消息接受者的父类，搜索方法从消息接收者的父类开始。
including the instance of the class that is to receive the message and the superclass at which to start searching for the method implementation.
上面注释我们提取了关于[super message]底层实现的两个核心点：
- 消息接收者仍然是子类对象
- 从父类开始查找方法的实现
[super message]的底层原理我们知道了，开头的疑问就可以解答了：
- [super class]调用的时候，消息接收者还是MJStudent，从消息接收者的父类MJPerson开始查找方法，因为class方法是NSObject的，就是返回消息接收者的当前类，所以最后打印还是MJStudent。
- 同理，[super superclass]调用的时候，消息接收者是MJStudent，从MJPerson开始查找方法，因为superclass方法是NSObject的，就是返回消息接收者的父类，所以最后打印还是MJPerson。
回到上面的run方法，执行以下代码：
MJStudent *student = [[MJStudent alloc] init];
[student run];
打印：
<MJStudent: 0x10068ede0>
当[student run]的时候，会调用[super run]，这时候消息接收者还是MJStudent，然后从MJPerson开始查找方法，找到MJPerson的run方法，然后调用，由于消息接收者还是MJStudent，所以打印:<MJStudent: 0x10068ede0>。
可以思考一下为什么[super run]会从父类开始查找方法？
如果从当前类查找方法，那不就又查到MJStudent的run方法了嘛！这时候就是死循环了，所以从这个角度也可以理解苹果为什么这么设计。
二. 如何降低unrecognized selector sent to instance/class崩溃
项目可能会用到:
[person performSelector:selector];
或者:
[array addObject:@"234"];
如果selector不存在，或者array是不可变数组都会崩溃，那么如何处理这种崩溃呢？
可以通过forwardInvocation拦截，如下：
- (void)run
{
NSLog(@"run-123");
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
// 本来能调用的方法,就不干扰他了
if ([self respondsToSelector:aSelector]) {
return [super methodSignatureForSelector:aSelector];
}
// 找不到的方法
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
// 找不到的方法，都会来到这里
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
//可以给NSObject添加分类，实现这个方法，在这里收集信息，上传到服务器
NSLog(@"找不到%@方法", NSStringFromSelector(anInvocation.selector));
}
执行代码：
MJPerson *person = [[MJPerson alloc] init];
[person run];
[person test1];
[person test2];
[person other];
打印：
run-123
找不到test1方法
找不到test2方法
找不到other方法
可以发现，拦截成功。
项目中我们可以给NSObject添加分类，实现forwardInvocation方法，在这里收集信息，然后上传到服务器。
这里只是简单提个思路，其实NSProxy这个类是专门用来做消息转发的，以后再说。
三. isMemberOfClass、isKindOfClass
NSObject作为最基础的类，其实好多东西是开源的，NSObject开源的东西在objc4的NSObject.mm文件里面，在NSObject.mm里面找到如下源代码：
//左边的类对象是否是右边传进来的家伙
- (BOOL)isMemberOfClass:(Class)cls {
return [self class] == cls;
}
//左边的类对象或者类对象的父类是否是右边传进来的家伙
- (BOOL)isKindOfClass:(Class)cls {
for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
if (tcls == cls) return YES;
}
return NO;
}
//左边的元类对象是否是右边传进来的家伙
+ (BOOL)isMemberOfClass:(Class)cls {
return object_getClass((id)self) == cls;
}
//左边的元类对象或者元类对象的父类是否是右边传进来的家伙
+ (BOOL)isKindOfClass:(Class)cls {
for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
if (tcls == cls) return YES;
}
return NO;
}
一般，左边是实例对象，右边传类对象，左边是类对象右边传元类对象。
这四个方法的内部实现如上注释，下面用代码验证：
id person = [[MJPerson alloc] init];
//MJPerson类对象 == MJPerson类对象，所以结果为1
NSLog(@"%d", [person isMemberOfClass:[MJPerson class]]);//1
//MJPerson类对象 != NSObject类对象，所以结果为0
NSLog(@"%d", [person isMemberOfClass:[NSObject class]]);//0
//MJPerson类对象 == MJPerson类对象，所以结果为1
NSLog(@"%d", [person isKindOfClass:[MJPerson class]]);//1
//MJPerson类对象的父类是NSObject类对象 == NSObject类对象，所以结果为1
NSLog(@"%d", [person isKindOfClass:[NSObject class]]);//1
//MJPerson元类对象 == MJPerson元类对象，所以结果为1
NSLog(@"%d", [MJPerson isMemberOfClass:object_getClass([MJPerson class])]);//1
//MJPerson元类对象的父类是NSObject元类对象 == NSObject元类对象，所以结果为1
NSLog(@"%d", [MJPerson isKindOfClass:object_getClass([NSObject class])]);//1
上面打印根据源码都比较好理解，如果是下面代码呢？
//NSObject元类对象 != NSObject类对象，所以结果为0
NSLog(@"%d", [NSObject isMemberOfClass:[NSObject class]]); // 0
//MJPerson元类对象 != MJPerson类对象，所以结果为0
NSLog(@"%d", [MJPerson isMemberOfClass:[MJPerson class]]); // 0
//MJPerson元类对象或者他的父类 != MJPerson类对象，所以结果为0
NSLog(@"%d", [MJPerson isKindOfClass:[MJPerson class]]); // 0
// 这句代码的方法调用者不管是哪个类（NSObject或其子类），都返回YES
// NSObject类对象 == NSObject类对象，所以结果为1，如果看不懂就往下看解释
NSLog(@"%d", [NSObject isKindOfClass:[NSObject class]]); // 1
NSLog(@"%d", [MJPerson isKindOfClass:[NSObject class]]); // 1
上面代码前三句也比较容易理解，主要是后两句，想要明白为什么先看下图：
isa和superclass.png
解释：可以看出NSObject元类对象的superclass指针指向NSObject类对象，所以无论MJPerson元类对象还是NSObject元类对象通过superclass指针最终都找到NSObject类对象，左边的NSObject类对象等于右边的NSObject类对象，所以最后两个打印是1。
一般，左边是实例对象，右边传类对象，左边是类对象右边传元类对象，上面属于特殊情况，开发中不会用到。
NSObject.mm里面好多方法的实现是开源的，没事多看看对于理解方法的本质有帮助。
四. 面试题
MJPerson.h
@interface MJPerson : NSObject
@property (copy, nonatomic) NSString *name;
- (void)print;
@end
MJPerson.m
@implementation MJPerson
- (void)print
{
NSLog(@"my name is %@", self->_name);
}
@end
下面代码可以调用成功吗？如果可以，打印结果是什么？
- (void)viewDidLoad {
[super viewDidLoad];
NSString *test = @"123";
id cls = [MJPerson class];
void *obj = &cls;
[(__bridge id)obj print];
}
打印结果:
my name is 123
为什么能执行成功？为什么这么打印？
① 为什么能执行成功？
如果我们下面这么写：
MJPerson *person = [[MJPerson alloc] init];
[person print];
内存结构为：person指针指向MJPerson实例对象，MJPerson实例对象里面的isa指向MJPerson类对象。
调用[person print]：先通过person指针找到MJPerson实例对象，再获取MJPerson实例对象的前8个字节(获取isa)，再根据isa找到MJPerson类对象，再在MJPerson类对象里面寻找print方法。
面试题和上面代码内存结构为：
内存
同理：obj指针指向cls指针，cls指针指向MJPerson类对象。调用[obj print]的时候：先通过obj指针找到cls指针，再获取cls指针的前8个字节，由于指针占用8字节，所以获取的就是MJPerson类对象的内存地址，所以可以调用成功。
② 为什么这么打印？
三种block内存分配.png
在iOS-底层-block1中讲过，内存中分为代码段、数据段、堆、栈，而且从上往下，内存地址越来越大，局部变量是分布在栈区的，而且是先分配高地址再分配低地址。
为了验证，栈区是先分配高地址再分配低地址，执行以下代码：
// 局部变量分配在栈空间
// 栈空间分配，从高地址到低地址分配
void test()
{
long long a = 4; // 0x7ffee638bff8
long long b = 5; // 0x7ffee638bff0
long long c = 6; // 0x7ffee638bfe8
long long d = 7; // 0x7ffee638bfe0
NSLog(@"%p %p %p %p", &a, &b, &c, &d);
}
打印结果看出，验证了，局部变量会被先分配在高地址再被分配在低地址。
那么为什么打印：“my name is 123”呢？
现在我们就能分析上面代码在栈空间内存中的结构了，上面代码test、cls、obj都是局部变量，他们在栈空间内存中结构如下：
其中test指针指向@"123"，cls指针指向MJPerson类对象，obj指针指向cls指针（上面说过了，当调用[obj print]，就是拿到obj指向内存地址的前8个字节(相当于获取isa)，就是获取cls，获取cls之后再拿到cls指向的MJPerson类对象，在MJPerson类对象里面寻找方法）。
由于是调用[obj print]，所以self->_name中的self就是obj，以前说过，MJPerson实例对象的底层结构是：
struct MJPerson_IMPL
{
Class isa;
NSString *_name;
};
所以，如果要找到_name，肯定就是访问isa后面8个字节，而后面8个字节就是test，所以最后打印是：“my name is 123”。
类比一下更容易明白，obj相当于person指针，cls相当于isa指针，test相当于_name成员，cls + test就是isa + _name就相当于MJPerson实例变量，这样类比是不是简单多了。
③ 如果没有 NSString *test = @"123"; 呢？
如下：
- (void)viewDidLoad {
[super viewDidLoad];
id cls = [MJPerson class];
void *obj = &cls;
[(__bridge id)obj print];
// NSLog(@"%@",self);
// NSLog(@"%p",[self class]);
// NSLog(@"%p",[ViewController class]);
}
这时候打印：
my name is <ViewController: 0x7fd3d06058a0>
这时候cls之前只有一句 [super viewDidLoad]，我们猜想就是这句代码起作用的。
其实[super viewDidLoad]底层就是：
struct objc_super arg = {
self, //消息接收者(receiver)
[ViewController class] //消息接收者的类对象
};
objc_msgSendSuper2(arg, sel_registerName("viewDidLoad"));
调用objc_msgSendSuper2函数，参数传入一个结构体和一个@selector(viewDidLoad)，结构体arg也是作为局部变量传进去的，所以在内存中的结构如下：
[super viewDidLoad].png
上面的self是ViewController实例对象，[ViewController class]是类对象，所以最后获取的肯定是self指针指向的实例对象。
打开上面的注释，如下打印也验证了我们所说的：
my name is <ViewController: 0x7ffbe85088f0>
<ViewController: 0x7ffbe85088f0>
0x10d7f9f68
0x10d7f9f68
小疑问：
在文章开头，我们说过objc_super结构体有两个成员，一个是消息接受者，一个是消息接收者的父类(代表从父类开始查找方法)，而且调用的是objc_msgSendSuper函数。为什么上面objc_super结构体的第二个成员是消息接收者的当前类对象，并且调用的是objc_msgSendSuper2函数呢？
其实通过命令将OC代码转成C++代码只是一个参考(但是八九不离十，基本上都对的上)，实际上也有可能不是这样的，[super viewDidLoad]转成汇编其实就是调用objc_msgSendSuper2函数。
在[super viewDidLoad]打断点，转成汇编，可以发现调用的就是objc_msgSendSuper2，如下：
objc_msgSendSuper2
objc_msgSendSuper2函数第一个参数的结构体是这样的
objc_msgSendSuper2(
{
self, //消息接收者(receiver)
[ViewController class] //消息接收者的类对象
}, sel_registerName("viewDidLoad"));
分别是消息接收者和当前类，当前类传进去之后objc_msgSendSuper2函数就会从当前类的父类开始查找方法，这个和文章开头说的其实是一样的。
在objc4搜索“ENTRY _objc_msgSendSuper2”，发现这个函数是汇编实现的：
ENTRY _objc_msgSendSuper2
UNWIND _objc_msgSendSuper2, NoFrame
MESSENGER_START
ldp x0, x16, [x0] // x0 = real receiver, x16 = class
ldr x16, [x16, #SUPERCLASS] // x16 = class->superclass
CacheLookup NORMAL
END_ENTRY _objc_msgSendSuper2
ENTRY _objc_msgLookupSuper2
UNWIND _objc_msgLookupSuper2, NoFrame
ldp x0, x16, [x0] // x0 = real receiver, x16 = class
ldr x16, [x16, #SUPERCLASS] // x16 = class->superclass
CacheLookup LOOKUP
END_ENTRY _objc_msgLookupSuper2
通过第5行代码的注释也可以看出，的确是从当前类的父类开始搜索方法的。
在代码最后添加如下代码：
NSLog(@"%@",self);
NSLog(@"%p",[self class]);
NSLog(@"%p",[ViewController class]);
NSLog(@"---------------------------");
long long *p = (long long *)obj;
NSLog(@"%p", *(p+1));
NSLog(@"%p", *(p+2));
打印结果：
my name is <ViewController: 0x7ffbe85088f0>
<ViewController: 0x7ffbe85088f0>
0x10d7f9f68
0x10d7f9f68
---------------------------
0x7ffbe85088f0
0x10d7f9f68
观察虚线下面可以发现，obj指针下面跳过一个指针指向的是ViewController实例对象，obj指针下面跳过两个指针指向的的确是ViewController类对象，和上图我们分析的一样，这也验证了[super viewDidLoad]底层调用的的确是_objc_msgSendSuper2函数。
五. 了解LLVM的中间代码(IR)
Objective-C在变为机器代码之前，会被LLVM编译器转换为中间代码(Intermediate Representation)
OC -> 中间代码(.ll) -> 汇编、机器代码
可以使用以下命令行指令生成中间代码：
clang -emit-llvm -S main.m
语法简介：
@ - 全局变量
% - 局部变量
alloca - 在当前执行的函数的堆栈帧中分配内存，当该函数返回到其调用者时，将自动释放内存
i32 - 32位4字节的整数
align - 对齐
load - 读出，store 写入
icmp - 两个整数值比较，返回布尔值
br - 选择分支，根据条件来转向label，不根据条件跳转的话类似 goto
label - 代码标签
call - 调用函数
具体可以参考官方文档：https://llvm.org/docs/LangRef.html
比如，[super forwardInvocation:anInvocation]转成中间代码就是：
call void bitcast (i8* (%struct._objc_super*, i8*, ...)* @objc_msgSendSuper2 to void (%struct._objc_super*, i8*, %1*)*)(%struct._objc_super* %7, i8* %18, %1* %12)
转成汇编就是：
objc_msgSendSuper2(struct, @selector(forwardInvocation:), anInvocation)
转为C++代码就是：
objc_msgSendSuper({self, class_getSuperclass(objc_getClass("MJPerson"))},
@selector(forwardInvocation:),
anInvocation);
在前面的学习中，我们都是把OC代码转成C++代码，因为C++代码语法和OC比较相识。但是转成的C++代码也不是百分百准确的，如果想要非常准确可以看汇编代码，但是汇编代码又比较难懂。除此之外还可以转成中间代码，中间代码是跨平台的，并且和汇编一样准确，个人还是推荐转成C++代码。
Demo地址：super
网友评论