iOS的内存管理

　　在Objective-C 这种面向对象的语言里,内存管理是个重要的概念。要想用一门语言写出内存使用效率高而且又没有bug的代码,就得掌握其内存管理模型的种种细节。

　　一旦理解了这些规则,你就会发现,其实Objective-C 的内存管理没那么复杂,而且有了"自动引用计数"(Automatic Reference Counting,ARC)之后,就变得更为简单了。ARC几乎把所有内存管理事宜都交给编译器来决定,开发者只需关注于业务逻辑。

引用计数

　　Objective-C 中的内存管理,也就是引用计数。可以用开关房间的灯为例来说明引用计数机制。

　 　假设办公室的照明设备只有一个。上班进入办公室的人需要照明。所以要把灯打开。而对于下班离开办公室的人来说,已经不需要照明了,所以需要把灯关掉。若 是很多人上下班,每个人都开灯或是关灯,那么办公室的情况又将如何呢?最早下班离开的人如果关了灯,那就会让办公室还没走的所有人的将处于一片黑暗之中。

　　解决这一问题的办法是使办公室在还有至少1人的情况下保持开灯状态,而在无人时保持关灯状态。

　　(1)最早进入办公室的人开灯。

　　(2)之后进入办公室的人,需要照明。

　　(3)下班离开办公室的人,不需要照明。

　　(4)最后离开办公室的人关灯(此时已无人需要照明)。

　　为判断是否还有人在办公室里,这里导入计数功能来计算"需要照明的人数"。下面让我们来看一看这一功能是如何运作的。

　　(1)第一个人进入办公室,"需要照明的人数"加1。计数值从0变成了1,因此要开灯。

　　(2)第二个人进入办公室,"需要照明的人数"加1。计数值从1变成了2。

　　(3)每当有人下班离开办公室时,"需要照明的人数"就减1。如计数值从2变成了1。

　　(4)最后一个人下班离开办公室时,"需要照明的人数"就减1。计数值从1变成了0,因此要关灯。

　　这样就能在不需要照明的时候保持关灯状态。办公室中仅有的照明设备也得到了很好的管理。

　　在 Objective-C 中,"对象"相当于办公室的照明设备。在现实世界中办公室的照明设备只有一个,但在Objective-C的世界里,虽然计算机资源有限,但一台计算机可以同时处理好几个对象。

　　此外,"对象的使用环境"相当于上班进入办公室的人。虽然这里的"环境"有时也指在运行中的程序代码、变量、变量作用域、对象等,但在概念上就是使用对象的环境。上班进入办公室的人对办公室照明设备发出的动作,与 Objective-C 的对应关系如下:

对照明设备所做的动作	对OC对象所做的动作
开灯	生成对象
需要照明	持有对象
不需要照明	释放对象
关灯	销毁对象

　　使用引用计数功能计算需要照明的人数,使办公室的照明得到了很好的管理。同样,使用引用计数功能,对象也能得到很好的管理,这就是 Objective-C 的内存管理。

内存管理的思考方式

　　首先来学习引用计数式内存管理的思考方式。看到"引用计数"这个名称,我们便会不自觉地联想到"某处有某物多少多少"而将注意力放在计数上。但其实,更加客观、正确的思考方式是:

• 　　自己生成的对象,自己持有。
• 非自己生成的对象,自己也能持有。
• 不再需要自己持有的对象时释放。
• 非自己持有的对象无法释放。

　　引用计数式的内存管理的思考方式仅此而已。按照这个思路,完全不必考虑引用计数。

　　上文出现了"生成"、"持有"、"释放"三个词。而在Objective-C内存管理中还要加上"废弃"一词。各个词表示的 Objective-C方法如表

对象操作	Objective-C方法
生成并持有对象	alloc/new/copy/mutableCopy等方法
持有对象	retain方法
释放对象	release方法
销毁对象	dealloc方法

　　这些有关Objective-C内存管理的方法,实际上不包括在该语言中,而是包含在Cocoa框架中用于OSX、iOS应用开发。

ARC规则

　　"引用计数式内存管理"的本质部分在ARC中并没有改变。就像"自动引用计数"这个名称表示的那样,ARC只是自动地帮助我们处理"引用计数"的相关部分。

所有权修饰符

　　Objective-C编程为了处理对象,可将变量类型定义为id类型或各种对象类型。

　　所谓对象类型就是指向NSObject这样的Objective-C类的指针,例如"NSObject*"。id类型用于隐藏对象类型的类名部分,相当于C语言中常用的"void*"。

　　ARC有效时,id类型和对象类型同C语言其他类型不同,其类型上必须附加所有权修饰符。所有权修饰符一共有4种。

• 　　__strong修饰符
• __weak修饰符
• __unsafe_unretained修饰符
• __autoreleasing修饰符

__strong修饰符

　　__strong修饰符是id类型和对象类型默认的所有权修饰符。也就是说,以下源代码中的id变量,实际上被附加了所有权修饰符。

　　

    id obj = [[NSObject alloc]init];

　　id和对象类型在没有明确指明所有权修饰符时,默认为__strong修饰符。上面的源代码与以下相同。

    id __strong obj = [[NSObject alloc]init];

　　该源代码在ARC无效时又该如何表述呢?

　　

    /*    ARC无效    */
    id obj = [[NSObject alloc]init];

　　该源代码一看则明,目前在表面上并没有任何变化。再看看下面的代码。

{
    id __strong obj = [[NSObject alloc]init];
}

　　此源代码明确指定了C语言的变量的作用域。ARC无效时,该源代码可记述如下:

/*    ARC无效    */
{
    id obj = [[NSObject alloc]init];
    [obj release];
}

　　为了释放生成并持有的对象,增加了调用release方法的代码。该源代码进行的动作同先前ARC有效时的动作完全一样。

　　如此源代码所示,附有__strong修饰符的变量obj在超出其变量作用域时,即在该变量被废弃时,会释放其被赋予的对象。

　　如"__strong"这个名称所示,__strong修饰符表示对对象的"强引用"。持有强引用的变量在超出其作用域时被废弃,随着强引用的失效,引用的对象会随之释放。

　　下面关注一下源代码中关于对象的所有者的部分。

{
    id __strong obj = [[NSObject alloc]init];
}

　　此源代码就是之前自己生成并持有对象的源代码,该对象的所有者如下:

{
/*
*  自己生成并持有对象
*/
    id __strong obj = [[NSObject alloc]init];
/*
* 因为变量obj为强引用
* 所以自己持有对象
*/
}
/*
* 因为变量obj超出其作用域,强引用失效,
* 所以自动地释放自己持有的对象。
* 对象的所有者不存在,因此废弃改对象。
*/

　　此外,对象的所有者和对象的生命周期是明确的。那么在取得非自己生成并持有的对象时又会如何呢?

　　

{
    id __strong obj = [NSMutableArray array];
}

　　在NSMutableArray类的array类方法的源代码中取得非自己生成并持有的对象,具体如下:

{
/*
* 取得非自己生成并持有的对象
*/

    id __strong obj = [NSMutableArray array];

/*
* 因为变量obj为强引用,
*  所以自己持有对象
*/
}
/*
* 因为变量obj超出其作用域,强引用失效,
* 所以自动地释放自己持有的对象
*/

　　在这里对象的所有者和对象的生存周期也是明确的。

{
/*
* 自己生成并持有的对象
*/

    id __strong obj = [[NSObject alloc]init];

/*
* 因为变量obj为强引用,
*  所以自己持有对象
*/
}
/*
* 因为变量obj超出其作用域,强引用失效,
* 所以自动地释放自己持有的对象。
* 对象的所有者不存在,因此废弃该对象。
*/

　　当然,附有__strong修饰符的变量之间可以相互赋值。

　　

    id __strong obj0 = [[NSObject alloc]init];

    id __strong obj1 = [[NSObject alloc]init];

    id __strong obj2 = nil;

    obj0 = obj1;

    obj2 = obj0;

    obj1 = nil;

    obj0 = nil;

    obj2 = nil;

　　下面来看一下生成并持有对象的强引用。

    id __strong obj0 = [[NSObject alloc]init];  /*  对象A */

    /*
     * obj0 持有对象A的强引用
     */

    id __strong obj1 = [[NSObject alloc]init];/*  对象B */

    /*
     * obj1 持有对象的B强引用
     */

    id __strong obj2 = nil;

    /*
     * obj2 不持有任何对象
     */

    obj0 = obj1;

    /*
     * obj0 持有由 obj1 赋值的对象B的强引用
     * 因为 obj0 被赋值,所以原先持有的对对象A的强引用失效。
     * 对象A的持有者不存在,因此废弃对象A。
     *
     * 此时,持有对象B的强引用的变量为
     * obj0 和 obj1
     */

    obj2 = obj0;

    /*
     * obj2 持有由 obj0 赋值的对象B的强引用
     *
     * 此时,持有对象B的强引用的变量为
     * obj0 , obj1 和 obj2
     */

    obj1 = nil;

    /*
     * 因为 nil 被赋予了 obj1 , 所以对对象B的强引用失效。
     *
     * 此时,持有对象B的强引用的变量为
     * obj0  和 obj2
     */

    obj0 = nil;

    /*
     * 因为 nil 被赋予了 obj0 , 所以对对象B的强引用失效。
     *
     * 此时,持有对象B的强引用的变量为
     * obj2
     */

    obj2 = nil;

    /*
     * 因为 nil 被赋予了 obj2 , 所以对对象B的强引用失效。
     * 对象B的所有者不存在,因此废弃对象B。
     */

　　通过上面这些不难发现,__strong修饰符的变量,不仅只在变量作用域中,在赋值上也能够正确地管理器对象的所有者。

　　当然,即便是 Objective-C类成员变量,也可以在方法参数上,使用附有__strong修饰符的变量。

@interface Test : NSObject
{
  id __strong _obj;
}

- (void)setObject:(id __strong)obj;
@end

@implementation Test
- (id)init
{
  self = [super init];
  return self;
}

- (void)setObject:(id __strong)obj
{
  _obj = obj;
}
@end

　　接着试着使用该类。

{
    id __strong test = [[Test alloc]init];
    [test setObject:[NSObject alloc]init];
}

　　该例中生成并持有对象的状态记录如下:

{
  id __strong test = [Test alloc]init];
  /*
    * test 持有Test对象的强引用
    */    

  [test setObject:[NSObject alloc]init];

    /*
    * Test 对象的_obj成员
    * 持有NSObject对象的强引用
    */
}
        /*
     * 因为test变量超出其作用域,强引用失效,
     * 所以自动释放Test对象
     * Test对象的所有者不存在,因此废弃该对象。
     *
     * 废弃Test对象的同时,
     * Test对象的 _obj成员也被废弃,
     * NSObject 对象的强引用失效
     * 自动释放NSObject对象
     * NSObject对象的所有者不存在,因此废弃该对象。
     */

　　像这样,无需额外工作便可以使用与类成员变量以及方法参数中。

　　另外,__strong修饰符通后面要讲的__weak修饰符和__autoreleasing修饰符一起,可以保证将附有这些修饰符的自动变量初始化为nil。

　　

    id __strong obj0;
    id __weak obj1;
    id __autoreleasing obj2;

　　以下源代码与上相同。

    id __strong obj0 = nil;
    id __weak obj1 = nil;
    id __autoreleasing obj2 = nil;

　　正如苹果宣称的那样,通过__strong修饰符,不必再次键入retain或者release,完美的满足了"引用计数式内存管理的思考方式":

• 自己生成的对象,自己所持有
• 非自己生成的对象,自己也能持有
• 不再需要自己持有的对象时释放
• 非自己持有的对象无法释放

　 　前两项"自己生成的对象,自己持有"和""非自己生成的对象,自己也能持有"只需通过对带__strong修饰符的变量赋值便可达成。通过废弃带 __strong修饰符的变量(变量作用域结束或是成员变量所属对象废弃)或者对变量赋值,都可以做到"不在需要自己持有的对象时释放"。最后一项"非自 己持有的对象无法释放",由于不必再次键入release,所以原本就不会执行。这些都满足于引用计数式内存管理的思考方式。

　　因为id类型和对象类型的所有权修饰符默认为__strong修饰符,所以不需要写上"__strong"。使ARC有效及简单的编程遵循了Objective-C内存管理的思考方式。

__weak修饰符

　　看起来好通过__strong修饰符编译器就能够完美的进行内存管理。但是遗憾的是,仅通过__strong修饰符是不能解决有些重大问题的。

　　这里提到的重大问题就是引用计数式内存管理中必然会发生的"循环引用"的问题。

　　例如,前面出现的带有__strong修饰符的成员变量在持有对象时,很容易发生循环引用问题。

@interface Test : NSObject
{
  id __strong _obj;
}

- (void)setObject:(id __strong)obj;
@end

@implementation Test
- (id)init
{
  self = [super init];
  return self;
}

- (void)setObject:(id __strong)obj
{
  _obj = obj;
}
@end

　　以下为循环引用。

{
  id test0 = [[Test alloc] init];
  id test1 = [[Test alloc] init];
  [test0 setObject:test1];
  [test1 setObject:test0];
}

　　为便于理解,下面写出了生成并持有对象的状态。

{

    id test0 = [[Test alloc] init];  /*  对象A */

    /*
     * test0 持有对象A的强引用
     */

    id test1 = [[Test alloc] init];/*  对象B */

    /*
     * test1 持有对象B的强引用
     */

    [test0 setObject:test1];

    /*
     * Test对象A的_obj成员变量持有Test对象B的强引用
     *
     * 此时,持有Test对象B的强引用变量为
     * Test对象A的_obj和test1
     */

    [test1 setObject:test0];

    /*
     * Test对象B的_obj成员变量持有Test对象A的强引用
     *
     * 此时,持有Test对象A的强引用变量为
     * Test对象B的_obj和test0
     */
 }
    /*
     * 因为test0变量超出其作用域,强引用失效,
     * 所以自动释放Test对象A。
     *
     * 因为test1变量超出其作用域,强引用失效,
     * 所以自动释放Test对象B。
     *
     * 此时,持有Test对象A的强引用的变量为
     * Test对象B的_obj。
     *
     * 此时,持有Test对象B的强引用的变量为
     * Test对象A的_obj。
     *
     * 发生内存泄漏。
     */

　　循环引用容易发生内存泄漏。所谓内存泄漏就是应当废弃的对象在超出其生存周期后继续存在。

　　此代码的本意是赋予变量test0的对象A和赋予标量test1的对象B在超出期变量作用域时被释放,即在对象不被任何变量持有的状态下予以废弃。但是,循环引用使得对象不能被再次废弃。

　　向下面这种情况,虽然只有一个对象,但在该对象持有其自身时,也会发生循环引用。

    id test = [[Test alloc]init];
    [test setObject:test];

　　怎么样才能避免循环引用呢?看到__strong修饰符就会意识到了,既然有strong,就应该会有与之对应的weak。也就是说,__weak修饰符可以避免循环引用。

　　__weak修饰符与__strong修饰符相反,提供弱引用。弱引用不能持有对象实例。我们来看下面的代码:

    id __weak obj = [[NSObject alloc]init];

　　变量obj上附加了__weak修饰符。实际上如果编译以上代码,编译器会发出警告。

　 　此源代码将自己生成并持有的对象赋值给附有__weak修饰符的变量obj。即变量obj持有对象的弱引用。因此,为了不以自己持有的状态来保存自己生 成并持有的对象,生成的对象会立即释放。编译器会发出警告。如果像下面这样,将对象赋值给附有__strong修饰符的变量之后再赋值给附有__weak 修饰符的变量,就不会发出警告了。

{
    id __strong obj0 = [[NSObject alloc]init];
    id __weak obj1 = obj0;
}

　　下面确认对象的持有状况。

{
  　/*
　　* 自己生成并持有对象
　　*/
    
　　id __strong obj0 = [[NSObject alloc]init];
　　
　　/*
　　* 因为obj0变量为强引用
　　* 所以自己持有对象
　　*/

　　id __weak obj1 = obj0;     

　　/*
　　* obj1变量持有生成对象的弱引用
　　*/
}
/*
* 因为obj0变量超出其作用域,强引用失效,
* 所以自动释放自己持有的对象
* 因为对象的所有者不存在,所以废弃该对象
*/

　　因为带__weak修饰符的变量(即弱引用)不持有对象,所以在超出其变量作用域时,对象即被释放。如果像下面这样将先前发生循环引用的类成员变量改成附有__weak修饰符的成员变量的话,该现象便可避免。

@interface Test : NSObject
{
    id __weak _obj;
}
- (void)setObject:(id __strong)obj;
@end

　　__weak修饰符还有一个优点。在持有某个对象的弱引用时,若该对象被废弃,则此弱引用将自动失效且处于nil被赋值的状态(空弱引用)。如以下代码所示。

 　　id __weak obj1 = nil;
    {
        id __strong obj0 = [[NSObject alloc]init];
        obj1 = obj0;
        NSLog(@"A: %@",obj1);
    }
    NSLog(@"B: %@",obj1);

　　此源代码执行结果如下:

    A: <NSObject: 0x753e180>
    B: (null)

　　下面我们来确认一下对象的持有情况,看看为什么得到这样的执行结果。

    id __weak obj1 = nil;
    {
        /*
         * 自己生成并持有对象
         */

        id __strong obj0 = [[NSObject alloc]init];

        /*
         * 因为obj0变量为强引用
         * 所以自己持有对象
         */

        obj1 = obj0;

        /*
         * obj1变量持有对象的弱引用
         */

        NSLog(@"A: %@",obj1);

        /*
         * 输出obj1变量持有的弱引用的对象
         */
    }

    /*
     * 因为obj0变量超出其作用域,强引用失效
     * 所以自动释放自己持有的对象
     * 因为对象无持有者,所以废弃该对象
     *
     * 废弃对象的同时
     * 持有该对象弱引用的obj1变量的弱引用失效,nil赋值给obj1。
     *
     *
     */

    NSLog(@"B: %@",obj1);
    /*
     * 输出赋值给obj1变量中的nil
     */

　　像这样,使用__weak,修饰符可避免循环引用。通过检查附有__weak修饰符的变量是否为nil,可以判断被赋值的对象是否已被废弃。

__unsafe_unretained修饰符

　　__unsafe_unretained修饰符正如其名unsafe所示,是不安全的所有权修饰符。尽管ARC式的内存管理是编程器的工作,但附有__unsafe_unretained修饰符的变量不属于编译器的内存管理对象。这一点在使用时需要注意。

    id __unsafe_unretained obj = [[NSObject alloc]init];

　　该源代码将自己生成并持有的对象赋值给附有__unsafe_unretained修饰符的变量中。虽然使用了unsafe变量,但编译器不会忽略,而是给与适当的警告。

　　附有__unsafe_unretained修饰符的变量同附有__weak修饰符的变量一样,因为自己生成并持有的对象不能继续为自己所有,所以生成的对象会立即被释放。到这里,__unsafe_unretained修饰符和__weak修饰符是一样的,下面我们来看看源代码的差异。

    id __unsafe_unretained obj1 = nil;
    {
        id __strong obj0 = [[NSObject alloc]init];
        obj1 = obj0;
        NSLog(@"A: %@",obj1);
    }

    NSLog(@"B: %@",obj1);

　　该源代码的执行结果为:

 A: <NSObject: 0x753e180>
 B: <NSObject: 0x753e180>

　　我们还像以前那样,通过确认对象的持有情况来理解发生了什么。

    id __unsafe_unretained obj1 = nil;
    {
        /*
         * 自己生成并持有对象
         */

        id __strong obj0 = [[NSObject alloc]init];

        /*
         * 因为obj0变量为强引用
         * 所以自己持有对象
         */

        obj1 = obj0;

        /*
         * 虽然 obj0 变量赋值给 obj1
         * 但是obj1 变量既不持有对象的强引用也不持有对象的弱引用
         */

        NSLog(@"A: %@",obj1);

        /*
         * 输出obj1变量表示的对象
         */
    }

    /*
     * 因为obj0变量超出其作用域,强引用失效
     * 所以自动释放自己持有的对象
     * 因为对象无持有者,所以废弃该对象。
     */

    NSLog(@"B: %@",obj1);
    /*
    * 输出赋值给obj1变量表示的对象
    *
    * obj1变量表示的对象
    * 已经被废弃(悬垂指针)!
    * 错误访问!
    */    

　　也就是说,最后一行的NSLog只是碰巧正常运行而已。虽然访问了已经被废弃的对象,但应用程序在个别运行状态下才会崩溃。

　　在使用__unsafe_unretained修饰符时,赋值给附有__strong修饰符的变量时有必要确保被复制的对象确实存在。

__autoreleasing修饰符

　　ARC有效时不能使用autorelease方法,也不能使用NSAutoreleasePool类。这样一来,虽然autorelease无法直接使用,但实际上,ARC有效时autorelease功能是起作用的。

　　ARC无效时会像下面这样来使用:

  　/*  ARC无效   */
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];
    id obj = [[NSObject alloc]init];
    [obj autorelease];
    [pool drain];

　　ARC有效时,该源代码也能写成下面这样:

  @autoreleasepool {
        id __autoreleasing obj = [[NSObject alloc]init];
    }

　　指定"@autoreleasepool块"来替代"NSAutoreleasePool类对象生成、持有以及废弃"这一范围。

　　另外ARC有效时,要通过将对象赋值给附加了__autoreleasing修饰符的变量来替代调用autorelease方法。对象赋值给附有__autoreleasing修饰符的变量等价于ARC无效时调用对象的autorelease方法,即对象被注册到autoreleasepool中。

　　也就是说可以理解为,在ARC有效时,用@autoreleasepool块替代NSAutoreleasePool类,用附有__autoreleasing修饰符的变量替代autorelease方法。

　　但是显示地附加__autoreleasing修饰符同显式的附加__strong修饰符一样罕见。

　　取得非自己生成并持有的对象时,如同一下源代码,虽然可以使用alloc/new/copy/mutableCopy以外的方法来取得对象,但该对象已被注册到了autoreleasepool。这同在ARC无效时取得调用了autorelease方法的对象是一样的。这是由于编译器会检查方法名是否以alloc/new/copy/mutableCopy开始,如果不是则自动将返回值的对象注册到autoreleasepool。另外init方法返回值的对象不注册到autoreleasepool。

   @autoreleasepool {
        id __strong obj = [NSMutableArray array];
    }

　　我们再来看看该源代码中对象的所有状况。

 @autoreleasepool {
        /*
         * 取得非自己生成并持有的对象
         */

        id __strong obj = [NSMutableArray array];

        /*
         * 因为变量obj为强引用
         * 所以自己持有对象
         *
         * 并且该对象
         * 由编译器判断其方法名
         * 自动注册到autoreleasepool
         */
    }
    /*
     * 因为变量obj超出其作用域,强引用失效,
     * 所以自动释放自己持有的对象
     *
     * 同时随着@autoreleasepool块的结束
     * 注册到autoreleasepool中的
     * 所有对象被自动释放
     *
     * 因为对象的所有者不存在,所以废弃对象
     */

　　像这样不使用__autoreleasing修饰符也能使对象注册到autoreleasepool。以下为取得非自己生成并持有对象时被调用方法的源代码示例。

+ (id)array
{
    return [[NSMutableArray alloc]init];
}

　　该源代码也没有使用__autoreleasing修饰符,可写成以下形式。

+ (id)array
{
    id obj = [[NSMutableArray alloc]init]
    return obj;
}

　　因为没有显式指定所有权修饰符,所以id obj同附有__strong修饰符的id _strong obj是完全一样的。由于return使得对象变量超出期作用域,所以该强引用对应的自己持有的对象会被自动释放,但该对象作为函数的返回值,编译器会自动将其注册到autoreleasepool。

　　以下为使用__weak修饰符的例子。虽然__weak修饰符是为了避免循环引用而使用的,但在访问附有__weak修饰符的变量时,实际上必定要访问注册到autoreleasepool的对象。

　　

  　id __weak obj1 = obj0;
    NSLog(@"class = %@ ",[obj1 class]);

　　以下源代码与此相同。

    id __weak obj1 = obj0;
    id __autoreleasing tmp = obj1;
    NSLog(@"class = %@ ",[tmp class]);

　　为什么在访问__weak修饰符的变量时必须要访问注册到autoreleasepool的对象呢?这是因为__weak修饰符只持有对象的弱引用,而在访问引用对象的过程中,该对象有可能被废弃。如果把要访问的对象注册到autoreleasepool中,那么在@autoreleasepool块结束之前都能确保该对象存在。因此,在使用附有__weak修饰符的变量时就必定要使用注册到autoreleasepool中的对象。

　　最后一个非显式地使用__autoreleasing修饰符的例子,同前面讲述的id obj和id __strong obj完全一样。那么id的指针id *obj又如何呢?可以由id __strong obj的例子类推出id __strong *obj吗? 其实,推出来的是id __autoreleasing *obj。同样的,对象的指针NSObject **obj便成为了NSObject* __autoreleasing *obj。

　　像这样,id的指针或对象的指针在没有显式的指定时会被附加上__autoreleasing修饰符。

　　比如,为了得到详细的错误信息,经常会在方法的参数中传递NSError对象的指针,而不是函数返回值。Cocoa框架中,大多数方法也是使用这种方法,如NSString的stringWithContentsOfFile:encoding:error类方法等。使用该方式的源代码如下所示。

　　 NSError *error = nil;
    BOOL result = [obj performOperationWithError:&error];
    

　　该方法的声明为:

- (BOOL) performOperationWithError:(NSError **)error;

　　同前面讲述的一样,id的指针或对象的指针会默认附加上__autoreleasing修饰符,所以等同于以下源代码。

　　

- (BOOL) performOperationWithError:(NSError * __autoreleasing*)error;

　　参数中持有对象指针的方法,虽然为响应其执行结果,需要生成NSError类对象,但也必须符合内存管理的思考方式。

　　作为alloc/new/copy/mutableCopy方法返回值取得的对象是自己生成并持有的,其他情况下便是取得非自己生成并持有的对象。因此,使用附有__autoreleasing修饰符的变量作为对象取得参数,与出alloc/new/copy/mutableCopy外其他方法的返回值取得对象完全一样,都会注册到autoreleasepool,并取得非自己生成并持有的对象。

　　比如,performOperationWithError方法的源代码应该是下面这样:

- (BOOL) performOperationWithError:(NSError * __autoreleasing*)error{
    /*  错误发生  */
    *error = [[NSError alloc]initWithDomain:MyAppDomain code:errorCode userInfo:nil];

    return NO;

}

　　因为声明为 NSError *__autoreleasing * 类型的error作为*error被赋值,所以能够返回注册到autoreleasepool中的对象。

　　然而,下面的源代码会产生编译器错误。

　　

    NSError *error = nil;
    NSError **pError = &error;

　　赋值给对象指针时,所有权修饰符必须一致。

　　此时,对象指针必须附加__strong修饰符

 NSError *error = nil;
 NSError * __strong *pError = &error;
    /*    编译正常    */

　　当然对于其他所有权修饰符也是一样。

 NSError  __weak *error = nil;
 NSError *__weak *pError = &error;
    /*    编译正常    */
 NSError  __unsafe_unretained *unsafeError = nil;
 NSError *__unsafe_unretained *pUnsafeError = &unsafeError;
    /*    编译正常    */

　　前面的方法参数中使用了附有__autoreleasing修饰符的对象指针类型。

- (BOOL) performOperationWithError:(NSError * __autoreleasing*)error;

　　然而调用方法却使用了附有__strong修饰符的对象指针类型。

    NSError __strong *error = nil;
    BOOL result = [obj performOperationWithError:&error];　　

　　对象指针赋值时,其所有权修饰符必须一致,但为什么该源代码没有警告就顺利通过编译了呢?实际上,编译器自动地将该源代码转化成了下面这种形式。

　　

     NSError __strong *error = nil;
     NSError __autoreleasing *tmp = error;
     BOOL result = [obj performOperationWithError:&tmp];　
     error = tmp;

　　当然也可以显式的指定方法参数中对象的指针类型的所有权修饰符。

- (BOOL) performOperationWithError:(NSError * __strong*)error;

　　向该源代码声明的一样,对象不注册到autoreleasepool也能够传递。但是前面也说过,只有作为alloc/new/copy/mutableCopy方法的返回值而取得对象时,能够自己生成并持有对象。其他情况即为"取得非自己生成并持有的对象",这些务必牢记。为了在使用参数取得对象时,贯彻内存管理的思考方式,我们要将参数声明为附有__autoreleasing修饰符的对象指针类型。

　　另外,虽然可以非显式的指定__autoreleasing修饰符,但在显式的指定__autorelesing修饰符时,必须注意对象变量要为自动变量(包括局部变量、函数以及方法参数)。

　　下面,我们换个话题,详细了解下@autoreleasepool。如以下源代码所示,ARC无效时,可将NSAutoreleasepool对象嵌套使用。

　　/*   ARC无效     */
   NSAutoreleasePool *pool0 = [[NSAutoreleasePool alloc]init];
        NSAutoreleasePool *pool1 = [[NSAutoreleasePool alloc]init];
            NSAutoreleasePool *pool2 = [[NSAutoreleasePool alloc]init];
                id obj = [[NSObject alloc]init];
                [obj autorelease];
            [pool2 drain];
        [pool1 drain];
    [pool0 drain];
    

　　同样的,@autoreleasepool块也可以嵌套使用。

  @autoreleasepool {
        @autoreleasepool {
            @autoreleasepool {
                id __autoreleasing obj = [[NSObject alloc]init];
            }
        }
    }

　　比如 ,在iOS应用程序模板中,向下面的main函数一样,@autoreleasepool块包含了全部程序。

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

　　NSRunLoop等实现不论ARC有效还是无效,均能够随时释放注册到autoreleasepool中的对象。

　　另外,即使ARC无效时,@autoreleasepool块也能够使用,如以下所示:

@autoreleasepool{
  id obj= [[NSObject alloc]init];
  [obj autorelease];
}

　　因为autoreleasepool范围以块级源代码表示,提高了程序的可读性,所以无论ARC 是否有效都推荐使用@autoreleasepool块,另外调试用的非公开函数_obj_autoreleasePoolPrint()都可使用,利用这一函数可有效地帮助我们调试注册到autoreleasepool上的对象。　　

规则

　　在ARC有效的情况下,编译源代码,必须遵循一定的规则。下面就是具体的ARC规则:

• 不能使用retain/release/retain/autorelease
• 不能使用NSAllocateObject/NSDeallocateObject
• 须遵守内存管理的方法命名规则
• 不要显示调用dealloc
• 使用@autoreleasepool块替代NSAutoreleasePool
• 不能使用区域(NSZone)
• 对象型变量不能作为C语言结构体(struct/union)的成员
• 通过"__bridge" 显式转换"id"和"void*"