arc的一点简单的学习记录

2023-12-16 16:58:39

?? strong:等同于"retain",属性成为对象的拥有者
? weak:属性是 weak pointer,当对象释放时会自动设置为 nil,记住 Outlet
应该使用 Weak
? unsafe_unretained:等同于之前的"assign",只有 iOS 4 才应该使用
? copy:和之前的 copy 一样,复制一个对象并创建 strong 关联
? assign:对象不能使用 assign,但原始类型(BOOL、int、float)仍然可以使用


readonly property
在 ARC 之前,我们可以如下定义一个 readonly property:
@property (nonatomic, readonly) NSString *result;

这会隐式地创建一个 assign property,这种用法对于 readonly 值来说是适 当的。毕竟你何必对只读数据进行 retain 呢?但上面在 ARC 中会报错:

"ARC forbids synthesizing a property of an Objective-C object with

unspecified ownership or storage attribute" 


你必须显式地使用 strong, weak 或 unsafe_unretained,多数情况下使用 strong 是正确的选择:
@property (nonatomic, strong, readonly) NSString *result;

对于 readonly property,我们应该总是使用 self.propertyName 来访问实 例变量(除了 init 和自定义的 getter 和 setter 方法)。否则直接修改实例变 量会混淆 ARC 并导致奇怪的 Bug。正确的方法是使用 class extension 重新定义 property 为 readwrite:

.h 文件:

@interface WeatherPredictor

@property (nonatomic, strong, readonly) NSNumber *temperature;

@end 


.m 文件:

@interface WeatherPredictor ()

@property (nonatomic, strong, readwrite) NSNumber *temperature;

@end 


dealloc 方法
另外启用 ARC 之后,dealloc 方法在大部分时候都不再需要了,因为你不能 调用实例对象的 release 方法,也不能调用[super dealloc]。假如原先的 dealloc 方法只是释放这些对象,Xcode 就会把 dealloc 方法完全移除。你不再 需要手动释放任何实例变量。

如果你的 dealloc 方法处理了其它资源(非内存)的释放,如定时器、Core Foundation 对象,则你仍然需要在 dealloc 方法中进行手动释放,如 CFRelease(), free()等。这时 Xcode 会保留 dealloc 方法,但是移除所有的 release 和[super dealloc]调用。如下:
- (void)dealloc
{
AudioServicesDisposeSystemSoundID(soundID);
}

?

指针保持对象的生命

ARC 的规则非常简单:只要还有一个变量指向对象,对象就会保持在内存中。当指针指向新值,或者指针不再存在时,相关联的对象就会自动释放。这条规则对于实例变量、synthesize属性、本地变量都是适用的。

我们可以按“所有权”(ownership)来考虑ARC 对象:NSString *firstName = self.textField.text;

firstName 变量成为NSString 对象的指针,也就是拥有者,该对象保存了文本输入框的内容。

arc的一点简单的学习记录

一个对象可以有多个拥有者,在上面例子中,UITextField的 text属性同样也是这个 String 对象的拥有者,也就是有两个指针指向同一个对象:

arc的一点简单的学习记录

随后用户改变了输入框的文本,此时 text 属性就指向了新的String对象。但原来的String 对象仍然还有一个所有者(firstName变量),因此会继续保留在内存中。

arc的一点简单的学习记录

只有当 firstName获得新值,或者超出作用域(本地变量方法返回时、实例变量对象释放时),String对象不再拥有任何所有者,retain计数降为0,这时对象会被释放。

arc的一点简单的学习记录

我们称 firstName和 textField.text指针为“strong”,因为它们能够保持对象的生命。默认所有实例变量和本地变量都是strong 类型的指针。

另外还有一种“weak”指针,weak变量仍然指向一个对象,但不是对象的拥有者:

__weak NSString *weakName = self.textField.text;

arc的一点简单的学习记录

weakName 变量和textField.text 属性都指向一个 String对象,但weakName不是拥有者。如果文本框的内容发生变化,则原先的String对象就没有拥有者,会被释放,此时weakName 会自动变成 nil,称为“zeroing” weak pointer:

arc的一点简单的学习记录

weak 变量自动变为nil 是非常方便的,这样阻止了weak 指针继续指向已释放对象。“摇摆指针”和“zombies”会导致非常难于寻找的Bug。zeroing weak pointer消除了类似的问题。 


CFURLCreateStringByAddingPercentEscapes()函数的参数需要两个CFStringRef对象,其中常量 NSString可以直接转换,因为不需要进行对象释放;但是text 参数不一样,它是传递进来的一个NSString 对象。而函数参数和局部变量一样,都是 strong 指针,这种对象在函数入口处会被retain,并且对象会持续存在直到指针被销毁(这里也就是函数返回时)。

对于 text参数,我们希望 ARC保持这个变量的所有权,同时又希望临时将它当作CFStringRef 对象来使用。这种情况下可以使用__bridge说明符,它告诉 ARC不要更改对象的所有权,按普通规则释放该对象即可。

多数情况下,Objective-C对象和 Core Foundation对象之间互相转换时,我们都应该使用__bridge。但是有时候我们确实需要给予ARC 某个对象的所有权,或者解除ARC 对某个对象的所有权。这种情况下我们就需要使用另外两种bridging casts:

  • __bridge_transfer:给予ARC 所有权

  • __bridge_retained:解除ARC 所有权 

只要你调用命名为 Create, Copy, Retain的 Core Foundation函数,你都需要使用 CFBridgingRelease()安全地将值传递给ARC。 

  • 使用 CFBridgingRelease(),从Core Foundation 传递所有权给Objective-C;

  • 使用 CFBridgingRetain(),从Objective-C 传递所有权给 CoreFoundation;

  • 使用__brideg,表示临时使用某种类型,不改变对象的所有权。 


在 ARC中,方法名如果以 alloc, init, new, copy, mutableCopy开头,就是返回 retain的对象,其它方法全部返回 autorelease 的对象。这条规则实际上与手动内存管理是一样的。因为ARC 代码需要与非ARC 协同工作。 



下面是我找到的比较好的文章

iOS5中加入了新知识，就是ARC,其实我并不是很喜欢它，因为习惯了自己管理内存。但是学习还是很有必要的。


在iOS开发过程中，属性的定义往往与retain, assign, copy有关，我想大家都很熟悉了，在此我也不介绍，网上有很多相关文章。

现在我们看看iOS5中新的关键字strong, weak, unsafe_unretained. 可以与以前的关键字对应学习strong与retain类似，weak与unsafe_unretained功能差不多（有点区别，等下会介绍，这两个新关键字与assign类似）。在iOS5中用这些新的关键字，就可以不用手动管理内存了，从java等其它语言转过来的程序员非常受用。


strong关键字与retain关似，用了它，引用计数自动＋1，用实例更能说明一切

  1. @property (nonatomic, strong) NSString *string1;   
  2. @property (nonatomic, strong) NSString *string2;  

有这样两个属性，

  1. @synthesize string1;   
  2. @synthesize string2;  


猜一下下面代码将输出什么结果？


  1. self.string1 = @"String 1";   
  2. self.string2 = self.string1;   
  3. self.string1 = nil;  
  4. NSLog(@"String 2 = %@", self.string2);  


结果是：String 2 = String 1

由于string2是strong定义的属性，所以引用计数＋1，使得它们所指向的值都是@"String 1", 如果你对retain熟悉的话，这理解并不难。


接着我们来看weak关键字：

如果这样声明两个属性：

  1. @property (nonatomic, strong) NSString *string1;   
  2. @property (nonatomic, weak) NSString *string2;  

并定义
  1. @synthesize string1;   
  2. @synthesize string2;  


再来猜一下，下面输出是什么？
  1. self.string1 = @"String 1";   
  2. self.string2 = self.string1;   
  3. self.string1 = nil;  
  4. NSLog(@"String 2 = %@", self.string2);  

结果是：String 2 = null

分析一下，由于self.string1与self.string2指向同一地址，且string2没有retain内存地址，而self.string1=nil释放了内存，所以string1为nil。声明为weak的指针，指针指向的地址一旦被释放，这些指针都将被赋值为nil。这样的好处能有效的防止野指针。在c/c++开发过程中，为何大牛都说指针的空间释放了后，都要将指针赋为NULL. 在这儿用weak关键字帮我们做了这一步。


接着我们来看unsafe_unretained

从名字可以看出，unretained且unsafe，由于是unretained所以与weak有点类似，但是它是unsafe的，什么是unsafe的呢，下面看实例。

如果这样声明两个属性：

并定义

  1. @property (nonatomic, strong) NSString *string1;   
  2. @property (nonatomic, unsafe_unretained) NSString *string2;  

再来猜一下，下面的代码会有什么结果？
  1. self.string1 = @"String 1";   
  2. self.string2 = self.string1;   
  3. self.string1 = nil;  
  4. NSLog(@"String 2 = %@", self.string2);  

请注意，在此我并没有叫你猜会有什么输出，因为根本不会有输出，你的程序会crash掉。

原因是什么，其实就是野指针造成的，所以野指针是可怕的。为何会造成野指针呢？同于用unsafe_unretained声明的指针，由于self.string1=nil已将内存释放掉了，但是string2并不知道已被释放了，所以是野指针。然后访问野指针的内存就造成crash.  所以尽量少用unsafe_unretained关键字。


strong,weak, unsafe_unretained往往都是用来声明属性的，如果想声明临时变量就得用__strong,  __weak, __unsafe_unretained,  __autoreleasing, 其用法与上面介绍的类似。

还是看看实例吧。

  1. __strong NSString *yourString = @"Your String";   
  2. __weak  NSString *myString = yourString;   
  3. yourString = nil;   
  4. __unsafe_unretained NSString *theirString = myString;  
  5. //现在所有的指针都为nil  

再看一个：

  1. __strong NSString *yourString = @"Your String";   
  2. __weak  NSString *myString = yourString;   
  3. __unsafe_unretained NSString *theirString = myString;  
  4. yourString = nil;   
  5. //现在yourString与myString的指针都为nil,而theirString不为nil,但是是野指针。  

__autoreleasing的用法介绍：

在c/c++，objective-c内存管理中有一条是：谁分配谁释放。 __autoreleasing则可以使对像延迟释放。比如你想传一个未初始化地对像引用到一个方法当中，在此方法中实始化此对像，那么这种情况将是__autoreleasing表演的时候。看个示例：

  1. - (void) generateErrorInVariable:(__autoreleasing NSError **)paramError{   
  2.     NSArray *objects = [[NSArray alloc] initWithObjects:@"A simple error", nil];  
  3.     NSArray *keys = [[NSArray alloc] initWithObjects:NSLocalizedDescriptionKey, nil];  
  4.     NSDictionary *errorDictionary = [[NSDictionary alloc] initWithObjects:objects forKeys:keys];  
  5.     *paramError = [[NSError alloc] initWithDomain:@"MyApp" code:1 userInfo:errorDictionary];  
  6. }  
  7. -(void)test  
  8. {  
  9.     NSError *error = nil;   
  10.     [self generateErrorInVariable:&error];  
  11.     NSLog(@"Error = %@", error);  
  12. }  

这样即便在函数内部申请的空间，在函数外部也可以使用，同样也适合谁分配谁释放的原则。

同样下面的代码也是类似原因, 只不过在没有开启ARC的情况下适用：

  1. -(NSString *)stringTest  
  2. {  
  3.     NSString *retStr = [NSString stringWithString:@"test"];  
  4.       
  5.     return [[retStr retain] autorelease];  
  6. }  

开启ARC后，应改为：
  1. -(NSString *)stringTest  
  2. {  
  3.     __autoreleasing NSString *retStr = [NSString alloc] initWithString:@"test"];  
  4.       
  5.     return retStr;  
  6. }  

arc的一点简单的学习记录

上一篇：单片机控制IIC协议EEPROM芯片AT24C02模块化编程


下一篇：C#函数式程序设计之函数、委托和Lambda表达式