__strong修饰符详解

__strong 修饰符

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

id obj = [[NSObject alloc] init];

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

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

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

    以下关注源代码中关于对象的所有者的部分:

{

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

}

   该对象的所有者如下:

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

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

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

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

    此处,对象的所有者和对象的生存周期是明确的。那么,在取得非自己生成切持有的对象时,如下:


      id __strong obj = [NSMutableArray array];

}

    在 NSMuatbleArray 类的 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 = obj1;

    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 被赋予了 obj0,所以对对象 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 = [[Tetst alloc] init];   

    [test setObject:[[NSObject alloc] init]];

}

    该例中声称并持有对象的状态如下:

{

    id __strong test = [[Tetst alloc] init];

    // test 持有 Test 对象的强引用

    [test setObject:[[NSObject alloc] init]];

    // Test 对象的 obj_ 成员, 持有 NSObject 对象的强引用

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

    通过 __strong 修饰符,不必再次输入 retain 或者release,完美地满足了“引用计数式内存管理的思考式”:

1.自己生成的对象,自己持有;

2.非自己生成的对象,自己也能持有;

3.不再需要自己持有的对象时释放;

4.非自己持有的对象无法释放。

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

    因为 id 类型和对象类型的所有权修饰符默认为 __strong 修饰符,所以不需要写上 “__strong”。



 // 结束,是另一种开始。

 // 作者会将所读所学摘录及分享

 // 本文参考《Objcetive-C高级编程iOS与OS X多线程和内存管理》

推荐阅读更多精彩内容