自动引用计数
看完了 Objective-C 高级编程 第一章，不得不吐槽，翻译这本书的作者的 English Level 和 Chinese Level 都和我差不多啊，看起来真吃力。。。
这一章的内容，实际中也很少会用到，然并卵。写下自己的笔记和一些体会，遇到问题时再回头看看吧。
文中常使用的 3 个函数：
extern void _objc_autoreleasePoolPrint(); // 在 iOS 不可用，在 OSX 上可用
extern uintptr_t _objc_rootRetainCount(id obj); // 在 iOS 和 OSX 都可用
CFGetRetainCount(CFTypeRef ref); // 在 iOS 和 OSX 都可用
内存管理的思考方式
个人观点，这种思考方式反而带来了更多纠结的地方，不用细究它。
- 自己生成的对象，自己持有。
- 非自己生成的对象，自己也能持有。
- 不再需要自己持有的对象时释放。
- 非自己持有的对象无法释放
自己生成的对象自己持有，是指使用以 alloc、new、copy、mutableCopy 开头的方法生成的对象。这句话能只有在 OS X 中使用 alloc 时得到了验证，代码参考 1-内存管理思考方式。个人认为吧，现在苹果在实现函数返回值的时候都已经进行了优化，不像在 MRC 时代需要先将返回值加入到 autoreleasepool 再重新 retain，而是直接将返回值传递给调用者。具体参考 objc_autoreleaseReturnValue() 和 objc_retainAutoreleasedReturnValue() 方法和图1。
// 只在 OSX 中有效
MyObject *a = [MyObject allocMyObject]; // a 的引用计数为 1
MyObject *b = [MyObject allocmyObject]; // b 的引用计数为 2
引用计数的实现
不像 GNUstep 将引用计数保存到对象占用的内存块头部，Apple 通过引用计数表实现对象的引用计数。GUNstep 的实现很取巧，Orz mark 一下。
struct obj_layout {
NSUInteger retained;
}
+ (id) alloc {
int size = sizeof(struct obj_layout) + 对象大小;
struct obj_layout *p = (struct obj_layout *)calloc(1, size);
return (id)(p + 1);
}
// 得到引用计数
inline NSUInteger NSExtraRefCount(id anObject) {
return ((struct obj_layout *)anObject)[-1].retained;
}
autorelease
注意：在大量产生
autorelease对象时，只要autoreleasepool没有废弃，那么生成的对象就不能被释放，可以使用下面的代码去避免它。在 ARC 中，如果对象变量是__strong修饰符，那么在变量出了作用域就会调用release，所以一般不用担心。
for (int i = 0; i < 图像数; ++i) {
@autoreleasepool {
// 读入图片，产生大量 autorelease 对象
}
// autorelease 对象被 release
}
GNUstep 在实现 autorelease 上，实际上使用了 IMP Caching，代码如下。
id autorelease_class = [NSAutoreleasePool class]
SEL autorelease_sel = @selector(addObject:);
IMP autorelease_imp = [autorelease_class methodForSelector:autorelease_sel];
// 实际上方法调用就是使用缓存的结果值
-(id)autorelease {
(*autorelease_imp)(autorelease_class, autorelease_sel, self);
}
所有权修饰符
所有权修饰符是为了处理 id 类型或对象指针类型的。ARC 有效时，id 类型和对象指针类型必须附加所有权修饰符。
// 对于 id 和普通对象类型，修饰符可以放在任何位置，XCode 编译器都能解释。
[__strong] id [__strong] a [__strong];
[__strong] NSObject [__strong] * [__strong] a [__strong];
// 但是对于 id* 和对象指针的指针，修饰符不能放在变量前
[__strong] id [__storng] * [不能] a [__strong];
// 出现提示错误为：
// '__strong' only applies to Objective-C object or block pointer types; type here is 'NSObject *__strong *' 。
// 这条警告对所有权修饰符的作用已经说明得很清楚了，它修饰的是对象，它指出变量在被赋值和离开作用域时应该怎样处理对象。
__strong
__strong 是 id 类型和对象指针的默认修饰符，但是对多级指针或 id * 类型必须明确指出所属修饰符。附有 __strong 修饰符的变量在超出变量作用域时（即在该变量被废弃时），会对其指向的对象发送 release 消息。
__weak
__weak 系统的实现有一个奇特的地方，就是在使用 __weak 引用的对象时，都会先将对象 retain 成 __strong 类型再使用，代码参考 4-弱引用。
id __strong a = [NSObject new];
id __weak b = a;
NSLog(@"%lu", _objc_rootRetainCount(a)); // 输出 1
NSLog(@"%lu", _objc_rootRetainCount(b)); // 输出 2
// 最后一条语句相当于：
// id __strong tmp = b;
// NSLog(@"%lu", _objc_rootRetainCount(tmp)); // 输出 2
// [tmp release]
// 书中说，__weak 附加的变量使用时，tmp 的所有权修饰符是 __autoreleasing，
// 但根据测试结果，自动释放池中并没有增加对象，有可能是 Apple 改了实现吧。
// 这也提醒我们在使用 __weak 前要使用 __strong 先绑定一下，不要让系统去绑定。
在使用 __weak 时，实际上还会调用下面两个函数，参见代码4-弱引用：
// id __strong a = [[MyObject alloc] init];
// id __weak b = a; 时会调用该函数，返回 NO，将在运行时发生异常终止
-(BOOL)allowsWeakReference;
// 每次把 __weak 的变量赋值给 __strong, __weak, __unsafe__unretained 和 __autoreleasing
// 修饰的变量都会调用该函数，由上面代码也能联想到，每次使用 __weak 的对象时也会调用该函数（每次都要生成一个临时对象）。
// 该函数返回 NO，便会给想要赋值的变量赋为 nil。
// 比如 id __weak a; 现在该函数返回 NO，则 id __strong b = a; 时，b 的值为 nil。
-(BOOL)retainWeakReference; // 要调用 [super retainWeakReference]
__autoreleasing
二级指针并不会保证初始化为 nil，应该显式初始化。现在 XCode 对本地二级指针必须严格指定修饰符，而对于函数参数传递的二级指针默认修饰符为 __autoreleasing。如果将函数参数传递的二级指针修饰符指定为 __strong，则对象的生命周期由指向 __strong 变量的作用域决定，参考2-二级指针参数传递。
我就说一句：不要管
__autoreleasing了。在 ARC 里面它没什么用，除了 Apple 脑子有病 在函数参数中将 pointer-to-pointer 的修饰符指定为__autoreleasing，参数传递明明可以用__strong实现。
void fun(id *a) {
// id *a 默认为：id __autoreleasing *a; *a 的对象加入自动释放池
*a = [NSObject new];
}
id __strong a = nil;
fun(&a);
// 会被转换为:
// id __autoreleasing * tmp = &a; （具体实现不清楚，因为测试结果显示没有把对象 a 加入到 autoreleaePool）
// fun(&tmp);
// a = *tmp;
__unsafe_unreatined
相当于 C 语言中的直接指针赋值。不像 __weak，对象销毁后指针不会被置为 nil。现在已不考虑该修饰符。
Toll-Free Bridge
Toll-Free Bridge 修饰符要放到数据类型前面，记为：(__bridge_transfer NSObject *)
__bridge_retained 用于将 Objective-C 对象转换为 Core Foundation 对象。
CFTypeRef CFBridgingRetain(id X) {
return (__bridge_retained CFTypeRef)X;
}
__bridge_transfer 用于将 Core Foundation 对象转换为 Objective-C 对象。
id CFBridgingRelease(CFTypeRef X) {
return (__bridge_transfer id)X;
}
__bridge 小心使用。使用 __bridge 代替 __bridge_retained 可能会出现悬垂指针（野指针）。
CFMutableArrayRef cfObject = NULL;
{
id obj = [[NSMutableArray alloc] init];
cfObject = (__bridge CFMutableArrayRef) obj; // 这里应该使用 __bridge_retained
}
// cfObject 在这里成为了野指针
使用 __bridge 代替 __bridge_transfer 可能会出现内存泄露。
{
CFMutableArrayRef cfObject = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
id obj = (__bridge id) cfObject; // 这里应该使用 __bridge_transfer
// 因为 obj 是 __strong 修饰符的，所以会发生强引用
// 不发生内存泄露的话这里应该手动释放 ofObject：CFRelease(cfObject) 或使用 __bridge_transfer
}
// 内存泄露
数组
静态数组
静态数组：指大小确定的数组，即 id objs[10]；它的使用和普通的变量没有区别。
动态数组
动态数组附加 __strong 修饰符时，使用方式和 C 语言的动态数组类似。对于附加了 __weak 修饰符的动态数组使用方式与 __strong 类似。但是最好不要使用 __autoreleasing 去使用动态数组（书中说，因为与设想的使用方法有差异，所以最好不用），但经过测试它会对数组的每个元素都使用 __autoreleasing（这样的话，__autoreleasing 应该最方便，也应该被推荐才对，因为每一个申请的对象系统都知道去释放。* 这是个问题 *），参见代码 3-数组。 __unsafe_unretained 修饰符与 void * 一样，就是 C 级别的指针，在 ARC 下不考虑。
NSObject * __strong *array = nil; // 不保证默认初始化为 nil 哦
array = (NSObject * __strong *)calloc(entries, sizeof(NSObject *));
// calloc 函数申请内存并将内存初始化为 0
// 也可以使用 malloc 和 memset，申请内存并初始化内存为 0
// 但是不能使用：
// array = (id __strong *)malloc(sizeof(id) * entries);
// for (NSUInteger i = 0; i < entries; ++i) array[i] = nil;
// 因为 malloc 申请的内存不保证值为 0，array[i] = nil 会调用 [array[i] release] 而出错
// 动态数组和静态数组一样使用
array[0] = [[NSObject alloc] init];
for (NSUInteger i = 0; i < entries; ++i) array[i] = nil;
free(array);
// 释放对象要使用 array[i] = nil，相当于 C++ 中调用对象的析构函数。
// 不能像初始化一样直接调用 memset，将数组置为 0，因为这样并不会调用它的释放函数。
// memcpy 和 realloc(可以减少内存分配，即释放一部分内存) 函数，在使用的使用要小心，尽量不用。
补充
尽管该文章都在使用对象的 retainCount 去判断对象的状态，但是被销毁的对象或给系统一个随机地址，系统都会默认返回 retainCount 为 1，所有不要把这个值在实际程序中作为判断依据。参考代码 5-系统返回 retainCount
@autoreleasepool {
long t = 0; // 用 t 保存地址
{
NSObject * __strong a = [[NSObject alloc] init];
NSObject * __strong b = a;
t = (long)b;
NSLog(@"块内： retainCount = %lu", CFGetRetainCount((void *)t)); // 输出 2
}
// 如果上面块内的 __strong 没有被释放，那么这里也应该输出 2；所以它们被释放了，且对象被销毁。
// 一个被销毁的对象仍然会输出 1
NSLog(@"块外：retainCount = %ld", CFGetRetainCount((void *)t));
// 即使传入 nil 也会输出 1
NSLog(@"nil：retainCount = %lu", _objc_rootRetainCount(nil));
}
