翻译 on 土土哥的技术 Blog

翻译-为什么objc_msgSend必须用汇编实现

Sat, 18 Jun 2016 16:19:23 +0000

译者前言

总是看到有人说用汇编实现objc_msgSend是为了速度快，当然这个不可否认。但是难道没有别的原因？于是就看到了这篇文章，遂翻译之！=。=

我自己的理解就是，用汇编实现，是为了应对不同的“Calling convention”，把函数调用前的栈和寄存器的参数、状态设置，交给编译器去处理。先看看原文吧。

原作者: Ari Grant 原文链接: Why objc_msgSend Must be Written in Assembly

开始

对于Objective-C来说，调用一个对象实例的方法，也叫作向这个对象实例**“发送消息”**，而每条“消息”，在编译阶段都会转变为一次对objc_msgSend函数的调用，调用的参数不仅有原本消息的所有参数，还有消息的接收者receiver和对应的方法selector。举个例子，下面的语句：

[receiver message:foo beforeDate:bar];

将会被编译成：

objc_msgSend(receiver, @selector(message:beforeDate:), foo, bar);

对于objc_msgSend函数的实现原理，前人已经做了大量的探索。所以，本文将会把重点放在objc_msgSend的一个之前没有太受到关注的点上，那就是：

objc_msgSend是不可能用Objective-C、C或者C++实现的。

THE RETURN TYPE - 返回类型

先看看如下两行代码：

NSUInteger n = [array count];
id obj = [array objectAtIndex:6];

直观上看，将会被编译成：

NSUInteger n = objc_msgSend(array, @selector(count));
id obj = objc_msgSend(array, @selector(objectAtIndex:), 6);

但是实际上这是不可能的，因为没有函数可以同时满足这两个调用。而且它的返回值也不能同时是NSUInteger和id。

而且，上面的代码也是无法编译通过的。那么，加上类型转换怎么样？

NSUInteger n = (NSUInteger (*)(id, SEL))objc_msgSend(array, @selector(count));
id obj = (id (*)(id, SEL, NSUInteger))objc_msgSend(array, @selector(objectAtIndex:), 6);

这下可以编译通过了，虽然看起来不直观。。。

objc_msgSend是一个Public的函数，在<objc/message.h>里声明，如果你想直接调用它，就必须按照上面的格式加上强制类型转换，要不然是无法编译通过的。但是objc_msgSend到底是如何实现，来支持各种返回类型的？本文后面会讲到。

THE IMP - 方法对应的函数指针

objc_msgSend函数的本质很简单，传入一个接受者对象实例receiver和方法名selector，它就会按照以下步骤执行：（译者注：只是最粗略的步骤=。=）

获取receiver得类Class
在Class的方法列表method table里面查找对应selector的方法实现
找到的话就调用，返回
找不到就在其父类中找，重复前面的步骤（直到没有父类为止）

整个流程很简单，沿着继承链，向上找到方法selector对应的函数指针即可，也就是IMP。同时，在每层Class中都有缓存，加快后续的方法查找。但是，这也只是objc_msgSend的实现细节，所以，接着往下看。

THE ARG TYPES AND COUNT - 参数类型和数量

简单来说，当objc_msgSend找到对应的函数指针后，只要用传入的参数调用这个函数即可。剩下来的就是找到一种方法，可以调用任意参数类型、数量的任意函数。

参数的数量很容易计算。然后我们可以把所有的参数都放入varargs，然后调用函数时传入即可。但是这样的话，每个Objective-C的方法都必须在其prologue（译者注：函数执行具体的“任务”前，所做的准备环节）里面把所有的参数从varargs里面提取出来。

这种把参数打包到varargs里面然后又取出来的办法显然是非常糟糕的，同时也是不必要的。

在C语言中，调用一个函数会被编译成对应的汇编语言指令，首先是设置参数（把参数放到寄存器、栈上），然后用如jump或者call的指令，跳到具体的函数代码地址处。如果我们想支持任意类型的函数类型，我们就必须写一个switch语句，把所有的参数组合情况都包含起来，这样才能正确的为任何形式的函数设置参数（译者注：即按照某种**“规范”、“约定”**，把参数依次存放到“约定”的寄存器、栈上），这显然是没有扩展性的，更是不可能的。

UNWINDING THE CALL - 拆解调用

objc_msgSend的解决办法，主要依据的是：当objc_msgSend被调用时，所有的参数已经被设置好了。

换一种方式来说，就是：在objc_msgSend开始执行时，栈帧（stack frame）的状态、数据，和各个寄存器的组合形式、数据，跟调用具体的函数指针（IMP）时所需的状态、数据，是完全一致的！

如下这行代码：

id obj = objc_msgSend(array, @selector(objectAtIndex:), 6);

在调用objc_msgSend时，需要设置三个参数，分别是被调用方receiver、方法名selector和最后一个整型参数6。这和具体的方法函数IMP的参数顺序、类型是完全一致的，也就是说，调用objc_msgSend前，设置的栈、寄存器的状态、数据正是调用具体的方法函数时需要的状态！

所以，当objc_msgSend找到要调用的函数实现IMP后，只需要把所有的对栈、寄存器的操作“倒”回到objc_msgSend执行开始的状态（类似于函数执行完成return返回前，做的“收尾处理”工作一样，即epilogue），直接jump/call到IMP函数指针对应的地址，执行指令即可，因为所有的参数已经被设置好了。

同时，当selector对应的IMP执行完成后，返回值也被正确的设置好了（在x86平台上，返回值被设置到了指定的寄存器eax/rax里，在arm上，则是r0寄存器），所以，我们也不必担心前文提到的不同类型的返回值问题了。

WRAP UP - 总结

把上面提到的所有解释综合起来，就是：在C语言里面调用函数，必须在编译时就知道调用的“状态”；而这些“状态”在运行时是无法得出或正确处理的，所以必须往底层走，用汇编处理。（译者注：这里不知道咋翻译好=。=，原文是：calling a function in C requires the signature to be known for each call-site at compile-time；doing so at run-time is not possible and so one must drop down into assembly and party there instead.）

UPDATE - 后续

有人指出objc_msgSend有可能是用GCC的扩展方法__builtin_apply_args，__builtin_apply，和__builtin_return实现的。这也正指出了一个事实，就是这些builtins方法是非常有必要的，因为单靠语言本身无法实现这些功能。实现objc_msgSend所需要的技巧，也正是实现这些builtins方法所需要的技巧。本文的目的并不是非要将什么是真正的C、什么不是真正的C分个清楚，只是为了指出objc_msgSend特殊罢了。

译者总结

开头也说了，我的理解是：用汇编实现，是为了应对不同的“Calling convention”，把函数调用前的栈和寄存器的参数、状态设置，交给编译器去处理。

嗯，以后不要再说用汇编实现只是为了快了=。=

Effective-Objective-C-读书笔记-Item-4-如何正确定义常量

Tue, 10 Mar 2015 16:07:23 +0000

前言

写博客果然比光看书要花时间=。=，书都快看完了，才写到第4节。但是总结一遍，的确印象深刻啊~~

这次的主题是“常量”，非常常用，又非常重要的东西~良好的代码规范、设计，少不了各种常量。

Item 4 - Prefer Typed Constants to Preprocessor #define

本节着重对比了常量的定义形式，类型常量和#define的区别、各自的特点。最后得出，我们应该用带有类型的常量，而不是#define。

一个简单的示例

应用中，少不了各种动画，也就少不了设定动画的时间长度，一般来说，我们会设定短、中、长几种时间常量，用于不同的场合，了解C语言的童鞋估计对“#define”宏定义不陌生，于是，可能就会如下这么定义：

#define ANIMATION_DURATION_SHORT 0.3
#define ANIMATION_DURATION_MIDDLE 0.6
#define ANIMATION_DURATION_LONG 1.0

于是，所有用到动画时长的地方，直接用这几个宏定义就行了。

乍一看，似乎没什么问题。

类型+不可变

先来看看宏定义干了什么。总的来说，#define就是“替换”，在编译时，将一切宏定义替换成定义后面的内容。（参考百度百科）

关键在于：

宏定义不会检查替换的“类型”，只要遇到，就做替换。
宏定义不保证“不可变”，因为可以重复定义，不能保证值不变。(这个我觉得是最容易让人忽略的地方)

所以，用宏定义定义常量，很“危险”。

正确的做法

恰当的常量，应该具备合适的常量名字、正确的类型，还有const、extern等关键字的修饰，当然，还要根据常量适用的“范围”，做出恰当的处理。一下举例说明。

只在函数中用的常量

只在函数中用的常量：

- (void)runAnimation {
 //动画时间长度常量
 static const NSTimeInterval kAnimationDurationLong = 1.0f;
 //...
}

static、const定义了它是静态不可变的；NSTimeInterval则“精确”指定了常量的类型。

只在一个“.m”文件中使用的常量

在类的实现文件“xxx.m”文件中定义常量，也是很常见的。

你可能会觉得，既然是一个类使用的，那就放在类的头文件里面定义不就好了。

但是这么想是错的=。=

因为所有要用到这个类的文件，都会无形当中包含了这些常量声明，将不必要的数据暴露在外面，这样是违反设计原则的，并且，如果常量名字取得不恰当，还有可能造成冲突。

所以，应该如下:

//XXX.m

//必须要static
static const NSTimeInterval kAnimationDurationLong = 1.0f;

@implementation XXX
//...
@end

需要注意的点：

一定要放在.m文件中。
必须是static，表示此常量作用域只在此.m文件中。如果不加static的话，常量就会在全局作用域中声明，可能会导致跟其他的常量冲突。
const，当然。
NSTimeInterval，确定的类型。
kAnimationDurationLong，“k”开头的命名，也算是Apple的规范了吧，内部常量统一以“k”开头。

全局常量

一般来说，最常见的全局常量就是发广播Notification时用的Notification的名字，往往都是一些字符串，下面就以这个为例子：

假设我们的类叫“TTGClass”，我们的类会向外发送Notification，所以需要定义一个Notification的名字常量供外界注册，如下：

//TTGClass.h
extern NSString * const TTGClassWorkBeginNotification;

//TTGClass.m
NSString * const TTGClassWorkBeginNotification = @"TTGClassWorkBeginNotification";

关键：

头文件中只是做声明，不做定义。所以用extern表示常量在别处定义的，尽量隐藏细节。
同类名做常量名字的开头，这个非常关键，因为Objective-C里面没有像Java那样的“包”机制，所以必须靠命名来划分不同的类，常量当然也要遵循这个规则。
NSString，确定的类型；const，表明常量；Notification后缀，表明用途。这些都是需要注意的。

总结

良好的代码，总是少不了定义各种常量，以避免“魔鬼数字、魔鬼字符串”。所以我们应该尽量避免少用#define定义常量，而是用带有类型的、const的常量，并且尽可能的缩小常量的作用域。

暴露的细节越少，出错的机会也就越小（忘了从哪里看到的=。=）

Effective-Objective-C-读书笔记-Item-3

Sat, 14 Feb 2015 08:51:51 +0000

前言

item 3讲的是Objective-C里面的“字面量语法”-“Literal Syntax”，个人觉得非常有用。

Item 3 - Prefer Literal Syntax over the Equivalent Methods

本节讲了Objective-C中的“字面量语法”，并且建议我们更多的使用这种语法，而不是使用传统的等价的函数方法。

引子

当我们使用Objective-C编程的时候，总会经常使用到几种Foundation框架中的基本类，如NSString、NSNumber、NSArray、NSDictionary，或者是它们的子类。例如，当我们想创建一个字符串的时候，会这么写：

NSString *str = @"a string";

不知道各位写这句的时候有没有觉得奇怪？为什么不用先“alloc”，再“initWithXXX”这么来创建呢。是的，这里创建字符串，就用到了Objective-C提供的“字面量语法”-“Literal Syntax”，而这种语法的“标志”就是“@”符号。有了字面量语法，我们就不用每次创建一些基本类型的时候，写一大堆alloc、init了。

NSNumber

字符串可以用字面量语法创建，数字类NSNumber肯定也可以，如下：

NSNumber *intNum = @1;
NSNumber *floatNum = @1.1f;
NSNumber *doubleNum = @1.1;
NSNumber *boolNum = @YES;
NSNumber *charNum = @'a';

//不用字面量语法
NSNumber *intNumber = [[NSNumber alloc] initWithInt:1];

看，是不是很方便~

NSArray

创建

数组算是最常用的一种数据结构了，如果没有字面量语法，创建数组可能是这样：

NSArray *numbers = [[NSArray alloc] initWithObjects:@1, @1.1, @2.0f, @YES, nil];

用字面量语法的话，就是这样：

NSArray *numbers = @[@1, @1.1, @2.0f, @YES];

存取值

创建了数组，肯定要从数组里面取值，用NSArray的方法就是这样：

//取
NSNumber *aNumber = [numbers objectAtIndex:2];
//存
NSMutableArray *mutableArray = [[NSMutableArray alloc] initWithArray:@[@1, @2, @3]];
[mutableArray replaceObjectAtIndex:1 withObject:@4];

跟C语言、Java这些语法很不一样啊，人家都是通过中括号“[]”直接用下标取值就可以。有了字面量同语法，Objective-C也可以这样:

//取
NSNumber *aNumber = numbers[2];
//存
NSMutableArray *mutableArray = [[NSMutableArray alloc] initWithArray:@[@1, @2, @3]];
mutableArray[1] = @4;

要注意的地方

传统的通过“initWithObjects”方法创建数组的时候，是根据最后的“nil”判断数组是否结束的，也就是说，用于初始化数组的元素中有“nil”值也不会导致异常（Exception），如下语句：

NSNumber *number1 = @1;
NSNumber *number2 = nil; //空指针
NSNumber *number3 = @3;

//创建
NSArray *numbers = [[NSArray alloc] initWithObjects:
 number1, number2, number3, nil];

//输出为1，因为number2，创建到number2就截止了
NSLog(@"numbers count: %d", numbers.count);

但是，如果用字面量语法创建，就是出问题：

NSNumber *number1 = @1;
NSNumber *number2 = nil;
NSNumber *number3 = @3;

//创建出现异常！！！
NSArray *numbers = @[number1, number2, number3];

NSLog(@"numbers count: %d", numbers.count);

因为字面量语法只是单纯的将中括号中的元素全部加到数组中，但是，Objective-C中的数组是不可以存放nil值的，所以程序会运行时抛出异常。

NSDictionary

创建

如果不用字面量语法创建字典，传统的创建函数简直令人匪夷所思：

// number1->@1
// number2->@2
NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:@1, @"number1", @2, @"number2", nil];

是不是很奇怪，value在前面，key在后面

所以，还是用新的语法吧：

NSDictionary *dict = @{@"number1" : @1, @"number2" : @2};

这样才符合“常识”嘛，key在前，value在后面，跟JSON的定义一样。

存取值

取值的语法跟NSArray的语法很想，只不过是将下标数字变成了key：

//传统
NSNumber *number1 = [dict objectForKey:@"number1"];
[dict setValue:@5 forKey:@"number1"];

//字面量语法
NSNumber *number2 = dict[@"number1"];
dict[@"number1"] = @6;

注意

需要注意的地方，跟创建数组一样，NSDictionary的value不能为nil值，否则会抛出异常。

总结

总的来说，使用字面量语法可以让代码更加清晰、简单，毕竟，更少的代码，有时候意味着更少的错误。

Effective-Objective-C-读书笔记-Item-2

Fri, 06 Feb 2015 08:43:46 +0000

前言

第二弹来了。

Item 2 - Minimize Importing Headers in Headers

这一节讲的是尽量在一个头文件中减少其它头文件的引入。

头文件

Objective-C和C语言、C++很像，都将类的实现与声明分开，用.h后缀名文件表示声明文件，用.m文件实现类。当要用到这个类的时候，只需要引入头文件即可，至于编译器、运行时是如何知道头文件里面的类对应的实现在哪里，在这了不做说明。一下用例子说明，先看看下面的类：

//Wheel.h
#import <Foundation/Foundation.h>

//车轮类
@interface Wheel : NSObject
@property(copy, nonatomic) NSString *manufacturer;
@property(assign, nonatomic) NSUInteger radius;
@end

第二个类

//Engine.h
#import <Foundation/Foundation.h>

//发动机类
@interface Engine : NSObject
@property(copy, nonatomic) NSString *manufacturer;
@property(assign, nonatomic) NSUInteger power;
@end

然后就是车类Car：

//Car.h
#import <Foundation/Foundation.h>

//汽车类，只有一个轮子，不要奇怪=。=
@interface Car : NSObject
@property(strong, nonatomic) Wheel *wheel;
@property(strong, nonatomic) Engine *engine;
@end

注意到少了什么东西没有？是的，写过C语言、C++的童鞋一下就能发现，Car类没有引入Engine和Wheel的头文件，肯定会编译出错的，因为编译器不知道Engine、Wheel类是啥。那好，我们加上下面两行：

#import "Wheel.h"
#import "Engine.h"

嗯。这样就不会出错了。但是这样真的好吗？Objective-C给我们提供了@class关键字，就是来解决这个问题的。

前置声明（forward declaration）

何为前置声明？看看下面的Car类的头文件例子。

//Car.h
#import <Foundation/Foundation.h>

//前置声明
@class Wheel;
@class Engine;

@interface Car : NSObject
@property(strong, nonatomic) Wheel *wheel;
@property(strong, nonatomic) Engine *engine;
@end

@class就是类的前置声明（forward declaration），就是告诉编译器“嗨，不用找了，Wheel类和Engine类是肯定存在的，用到的时候再找”。有了前置声明，我们就不用显式的引入Wheel类和Engine类了。

当然，在Car类的实现文件.m文件中，我们还是要显式的引入Wheel和Engine类的，因为在这里我们要具体用到这两个类了，当然要知道类的细节。

为何不要import？

为什么不直接import呢？因为如果直接用import引入Wheel和Engine的声明，那么任何import引入了Car类的文件，也同时会引入Wheel、Engine类的声明，而且最终我们可能并不一定会直接跟Wheel、Engine类打交道，这样不就引入了“没有用”的类了吗？而且这样做很可能造成文件引入成“环”。

虽然import可以避免重复声明造成编译出错，传统的C语言、C++在声明的时候也可以通过如下方式避免重复声明：

#ifndef _WHEEL_H_
#define _WHEEL_H_

//声明内容...

#endif

但是既然Objective-C有@class这种前置声明的办法，为何不用呢。

必须用import的时候

当然，@class这样的前置声明并不能解决一切头文件引入的问题，如下这样的类，就必须要用import：

#import <Foundation/Foundation.h>

//Car 的声明
#import "Car.h"

//Driver protocol的定义
#import "Driver.h"

@interface BigCar : Car <Driver>
@end

是的，当类需要被继承、定义的protocol需要实现的时候，就需要import相关的头文件了（protocol的实现如果跟类的使用者没有关联，可以定义在类的实现文件中的“扩展category”中）,当然，还有@protocol这样的protocol的前置声明，怎么用就留给读者自己查阅相关资料了。

总结

大费周章的讲了这么多，其实目的就是一个：尽量少在头文件里面引入其他头文件。

最终的目的就是只暴露最少的细节。

写代码有段时间了，一直都在琢磨这句话，希望读者也能好好体会~

Effective-Objective-C-读书笔记-Item-1

Wed, 04 Feb 2015 17:17:08 +0000

前言

一直都在做项目，没什么时间作总结，感觉很不是滋味。现在放假了，嗯，终于有时间了~~哈哈（天生程序猿一枚好不好=。=）最近开始读英文版的Effective Objective-C 2.0，觉得不错，就总结些东西，分享给各位读者吧。

Item 1 - Familiarize Yourself with Objective-C’s Roots

第一章的目的，就是让大家熟悉Objective-C，自然，标题的意思也就是“了解Objective-C的基本概念”，不多说，开写。

消息与运行时

总的来说，Objective-C跟C++、Java这些面向对象的语言是非常相似的，但是还是有许多不同的地方。如果你是第一次看到Objective-C的语法，一定觉得非常奇怪，因为Objective-C使用的是基于消息（Message）的框架，而不是传统的方法、函数调用。如下：

//Objective-C
Person *person = [Person new];
[person setName:@"tutuge" age:24];

//Java
Person person = new Person();
person.setNameAndAge("tutuge", 24);

//C++
Person *person = new Person;
person->setNameAndAge("tutuge", 24);

很奇怪是不是，各种中括号。但是我觉得，Objective—C这么设计就是为了时刻提醒你，“我是基于消息机制的！”。消息，的确是Objective-C与Java、C++这种语言最大的不同，而且，这种不同远不止在语法上面。简单来说如下两点：

基于消息的调用： 所有的函数调用都是在“运行时”决定的。
基于方法的调用： 所有的函数调用都是在“编译时”决定的，就是编译器编译时决定的。

其实，连被调方法的对象类型，都是在运行时决定的。所以说，Objective-C的运行时系统，担负了绝大部分的工作。这么设计的优点，举个例子，就是当运行时系统升级时，原有的代码不用重新编译即可“享受”升级带来的好处。

C的超集

Objective-C是C语言的超集，所以C语言所具有的一切特性，Objective-C都可以兼容，充分理解C语言的内存模型，对理解Objective-C很有帮助。如下：

NSString *str = @"a string";

这一行代码跟C语言没有什么不同，（忽略@符号=。=），原理跟C语言也是一致的，就是str指针是NSString类型的指针，指向了一块存着字符串“a string”的内存区域。不同的是，在Objective-C里，所有的对象只可以声明为指针类型，所以如下代码是不合理的：

NSString str;

为了更充分的理解，咱们看看如下例子：

NSString *str1 = @"a string";
NSString *str2 = str1;

熟悉C语言的朋友应该知道这是怎么回事，内存当中只有一块区域储存着“a string”这个字符串，str1、str2都是指向着这个区域的字符串指针。如下图：

str1、str2都在栈内存上分配的，就是字符串（NSString）类型的指针。
“a string”字符串实际储存在堆内存上。
str1、str2均指向同一块内存区域。

此处的栈内存、堆内存跟C语言中的概念也是一样的，不同的是，在Objective-C中，我们不用手动去malloc、free内存，Objective-C使用内存计数计数帮我们管理内存。

结构体，基本类型

在Objective-C中，并不是所有的变量都是指针类型的，像int、float、double这些依旧是传统的“栈上分配”的，当然，还有结构体struct、枚举enum、联合union等。如：

CGPoint point = CGPointMake(10, 10);
CGRect frame = CGRectMake(0, 0, 10, 10);

这的CGPoint、CGRect都是结构体，但是都是直接在栈上分配内存的，以减少过度使用Objective-C类型的类（减少运行时的压力），各位读者使用的时候要注意。

总结

零散的说了一些Objective-C的特点，远远不足以讲明白Objective-C，我这只是根据Effective Objective-C这本书给个引子，还是推荐Apple的官方教程、文档，要想掌握扎实，还是要一步一步来~