Objective-C代码学习大纲(5)

2011-05-11 14:06 佚名 otierney  字号:T | T
一键收藏,随时查看,分享好友!

本文为台湾出版的《Objective-C学习大纲》的翻译文档,系统介绍了Objective-C代码,很多名词为台湾同胞特指词汇,在学习时仔细研读才能体会。

AD:干货来了,不要等!WOT2015 北京站演讲PPT开放下载!

 

记忆体管理

到目前为止我都刻意避开 Objective-C 的记忆体管理议题。你可以唿叫物件上的 dealloc,但是若物件裡包含其他物件的指标的话,要怎么办呢?要释放那些物件所佔据的记忆体也是一个必须关注的问题。当你使用 Foundation framework 建立 classes 时,它如何管理记忆体?这些稍后我们都会解释。

注意:之前所有的範例都有正确的记忆体管理,以免你混淆。

Retain and Release(保留与释放)

Retain 以及 release 是两个继承自 NSObject 的物件都会有的 methods。每个物件都有一个内部计数器,可以用来追踪物件的 reference 个数。如果物件有 3 个 reference 时,不需要 dealloc 自己。但是如果计数器值到达 0 时,物件就得 dealloc 自己。[object retain] 会将计数器值加 1(值从 1 开始),[object release] 则将计数器值减 1。如果唿叫 [object release] 导致计数器到达 0,就会自动 dealloc。

 

  1. Fraction.m 
  2.  
  3. ... 
  4.  
  5. -(void) dealloc { 
  6.  
  7. printf( "Deallocing fraction\n" ); 
  8.  
  9. [super dealloc]; 
  10.  
  11.  
  12. ... 

 

  1. main.m 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. #import 
  6.  
  7. int main( int argc, const char *argv[] ) { 
  8.  
  9. Fraction *frac1 = [[Fraction alloc] init]; 
  10.  
  11. Fraction *frac2 = [[Fraction alloc] init]; 
  12.  
  13. // print current counts 
  14.  
  15. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] ); 
  16.  
  17. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] ); 
  18.  
  19. // increment them 
  20.  
  21. [frac1 retain]; // 2 
  22.  
  23. [frac1 retain]; // 3 
  24.  
  25. [frac2 retain]; // 2 
  26.  
  27. // print current counts 
  28.  
  29. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] ); 
  30.  
  31. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] ); 
  32.  
  33. // decrement 
  34.  
  35. [frac1 release]; // 2 
  36.  
  37. [frac2 release]; // 1 
  38.  
  39. // print current counts 
  40.  
  41. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] ); 
  42.  
  43. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] ); 
  44.  
  45. // release them until they dealloc themselves 
  46.  
  47. [frac1 release]; // 1 
  48.  
  49. [frac1 release]; // 0 
  50.  
  51. [frac2 release]; // 0 
  52.  

output

  1. Fraction 1 retain count: 1 
  2.  
  3. Fraction 2 retain count: 1 
  4.  
  5. Fraction 1 retain count: 3 
  6.  
  7. Fraction 2 retain count: 2 
  8.  
  9. Fraction 1 retain count: 2 
  10.  
  11. Fraction 2 retain count: 1 
  12.  
  13. Deallocing fraction 
  14.  
  15. Deallocing fraction 

Retain call 增加计数器值,而 release call 减少它。你可以唿叫 [obj retainCount] 来取得计数器的 int 值。 当当 retainCount 到达 0,两个物件都会 dealloc 自己,所以可以看到印出了两个 "Deallocing fraction"。

Dealloc

当你的物件包含其他物件时,就得在 dealloc 自己时释放它们。Objective-C 的一个优点是你可以传递讯息给 nil,所以不需要经过一堆防错测试来释放一个物件。

AddressCard.h

 

  1. #import 
  2.  
  3. #import 
  4.  
  5. @interface AddressCard: NSObject { 
  6.  
  7. NSString *first; 
  8.  
  9. NSString *last; 
  10.  
  11. NSString *email; 
  12.  
  13.  
  14. -(AddressCard*) initWithFirst: (NSString*) f 
  15.  
  16. last: (NSString*) l 
  17.  
  18. email: (NSString*) e; 
  19.  
  20. -(NSString*) first; 
  21.  
  22. -(NSString*) last; 
  23.  
  24. -(NSString*) email; 
  25.  
  26. -(void) setFirst: (NSString*) f; 
  27.  
  28. -(void) setLast: (NSString*) l; 
  29.  
  30. -(void) setEmail: (NSString*) e; 
  31.  
  32. -(void) setFirst: (NSString*) f 
  33.  
  34. last: (NSString*) l 
  35.  
  36. email: (NSString*) e; 
  37.  
  38. -(void) setFirst: (NSString*) f last: (NSString*) l; 
  39.  
  40. -(void) print; 
  41.  
  42. @end 
  43.  
  44. AddressCard.m 
  45.  
  46. #import "AddressCard.h" 
  47.  
  48. #import 
  49.  
  50. @implementation AddressCard 
  51.  
  52. -(AddressCard*) initWithFirst: (NSString*) f 
  53.  
  54. last: (NSString*) l 
  55.  
  56. email: (NSString*) e { 
  57.  
  58. self = [super init]; 
  59.  
  60. if ( self ) { 
  61.  
  62. [self setFirst: f last: l email: e]; 
  63.  
  64.  
  65. return self; 
  66.  
  67.  
  68. -(NSString*) first { 
  69.  
  70. return first; 
  71.  
  72.  
  73. -(NSString*) last { 
  74.  
  75. return last; 
  76.  
  77.  
  78. -(NSString*) email { 
  79.  
  80. return email; 
  81.  
  82.  
  83. -(void) setFirst: (NSString*) f { 
  84.  
  85. [f retain]; 
  86.  
  87. [first release]; 
  88.  
  89. ffirst = f; 
  90.  
  91.  
  92. -(void) setLast: (NSString*) l { 
  93.  
  94. [l retain]; 
  95.  
  96. [last release]; 
  97.  
  98. llast = l; 
  99.  
  100.  
  101. -(void) setEmail: (NSString*) e { 
  102.  
  103. [e retain]; 
  104.  
  105. [email release]; 
  106.  
  107. eemail = e; 
  108.  
  109.  
  110. -(void) setFirst: (NSString*) f 
  111.  
  112. last: (NSString*) l 
  113.  
  114. email: (NSString*) e { 
  115.  
  116. [self setFirst: f]; 
  117.  
  118. [self setLast: l]; 
  119.  
  120. [self setEmail: e]; 
  121.  
  122.  
  123. -(void) setFirst: (NSString*) f last: (NSString*) l { 
  124.  
  125. [self setFirst: f]; 
  126.  
  127. [self setLast: l]; 
  128.  
  129.  
  130. -(void) print { 
  131.  
  132. printf( "%s %s <%S
  133.  
  134. ", [first cString], 
  135.  
  136. [last cString], 
  137.  
  138. [email cString] ); 
  139.  
  140.  
  141. -(void) dealloc { 
  142.  
  143. [first release]; 
  144.  
  145. [last release]; 
  146.  
  147. [email release]; 
  148.  
  149. [super dealloc]; 
  150.  
  151.  
  152. @end 
  153.  
  154. main.m 
  155.  
  156. #import "AddressCard.h" 
  157.  
  158. #import 
  159.  
  160. #import 
  161.  
  162. int main( int argc, const char *argv[] ) { 
  163.  
  164. NSString *first =[[NSString alloc] initWithCString: "Tom"]; 
  165.  
  166. NSString *last = [[NSString alloc] initWithCString: "Jones"]; 
  167.  
  168. NSString *email = [[NSString alloc] initWithCString: "[email protected]"]; 
  169.  
  170. AddressCard *tom = [[AddressCard alloc] initWithFirst: first 
  171.  
  172. last: last 
  173.  
  174. email: email]; 
  175.  
  176. // we're done with the strings, so we must dealloc them 
  177.  
  178. [first release]; 
  179.  
  180. [last release]; 
  181.  
  182. [email release]; 
  183.  
  184. // print to show the retain count 
  185.  
  186. printf( "Retain count: %i\n", [[tom first] retainCount] ); 
  187.  
  188. [tom print]; 
  189.  
  190. printf( "\n" ); 
  191.  
  192. // free memory 
  193.  
  194. [tom release]; 
  195.  
  196. return 0; 
  197.  

output

  1. Retain count: 1 
  2.  
  3. Tom Jones  

如 AddressCard.m,这个範例不仅展示如何撰写一个 dealloc method,也展示了如何 dealloc 成员变数。

每个 set method 裡的叁个动作的顺序非常重要。假设你把自己当参数传给一个自己的 method(有点怪,不过确实可能发生)。若你先 release,「然后」才 retain,你会把自己给解构(destruct,相对于建构)!这就是为什么应该要 1) retain 2) release 3) 设值 的塬因。

通常我们不会用 C 形式字串来初始化一个变数,因为它不支援 unicode。下一个 NSAutoreleasePool 的例子会用展示正确使用并初始化字串的方式。

这只是处理成员变数记忆体管理的一种方式,另一种方式是在你的 set methods 裡面建立一份拷贝。

Autorelease Pool

当你想用 NSString 或其他 Foundation framework classes 来做更多程式设计工作时,你需要一个更有弹性的系统,也就是使用 Autorelease pools。

当开发 Mac Cocoa 应用程式时,autorelease pool 会自动地帮你设定好。

 

  1. main.m 
  2.  
  3. #import 
  4.  
  5. #import 
  6.  
  7. #import 
  8.  
  9. int main( int argc, const char *argv[] ) { 
  10.  
  11. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  12.  
  13. NSString *str1 = @"constant string"; 
  14.  
  15. NSString *str2 = [NSString stringWithString: @"string managed by the pool"]; 
  16.  
  17. NSString *str3 = [[NSString alloc] initWithString: @"self managed string"]; 
  18.  
  19. // print the strings 
  20.  
  21. printf( "%s retain count: %x\n", [str1 cString], [str1 retainCount] ); 
  22.  
  23. printf( "%s retain count: %x\n", [str2 cString], [str2 retainCount] ); 
  24.  
  25. printf( "%s retain count: %x\n", [str3 cString], [str3 retainCount] ); 
  26.  
  27. // free memory 
  28.  
  29. [str3 release]; 
  30.  
  31. // free pool 
  32.  
  33. [pool release]; 
  34.  
  35. return 0; 
  36.  

 

output

  1. constant string retain count: ffffffff 
  2.  
  3. string managed by the pool retain count: 1 
  4.  
  5. self managed string retain count: 1 

如果你执行这个程式,你会发现几件事:第一件事,str1 的 retainCount 为 ffffffff。

另一件事,虽然我只有 release str3,整个程式却还是处于完美的记忆体管理下,塬因是第一个常数字串已经自动被加到 autorelease pool 裡了。还有一件事,字串是由 stringWithString 产生的。这个 method 会产生一个 NSString class 型别的字串,并自动加进 autorelease pool。

千万记得,要有良好的记忆体管理,像 [NSString stringWithString: @"String"] 这种 method 使用了 autorelease pool,而 alloc method 如 [[NSString alloc] initWithString: @"String"] 则没有使用 auto release pool。

在 Objective-C 有两种管理记忆体的方法, 1) retain and release or 2) retain and release/autorelease。

对于每个 retain,一定要对应一个 release 「或」一个 autorelease。

下一个範例会展示我说的这点。

  1. Fraction.h 
  2.  
  3. ... 
  4.  
  5. +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d; 
  6.  
  7. ... 
  8.  
  9. Fraction.m 
  10.  
  11. ... 
  12.  
  13. +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d { 
  14.  
  15. Fraction *ret = [[Fraction alloc] initWithNumerator: n denominator: d]; 
  16.  
  17. [ret autorelease]; 
  18.  
  19. return ret; 
  20.  
  21.  
  22. ... 
  23.  
  24. main.m 
  25.  
  26. #import 
  27.  
  28. #import "Fraction.h" 
  29.  
  30. #import 
  31.  
  32. int main( int argc, const char *argv[] ) { 
  33.  
  34. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  35.  
  36. Fraction *frac1 = [Fraction fractionWithNumerator: 2 denominator: 5]; 
  37.  
  38. Fraction *frac2 = [Fraction fractionWithNumerator: 1 denominator: 3]; 
  39.  
  40. // print frac 1 
  41.  
  42. printf( "Fraction 1: " ); 
  43.  
  44. [frac1 print]; 
  45.  
  46. printf( "\n" ); 
  47.  
  48. // print frac 2 
  49.  
  50. printf( "Fraction 2: " ); 
  51.  
  52. [frac2 print]; 
  53.  
  54. printf( "\n" ); 
  55.  
  56. // this causes a segmentation fault 
  57.  
  58. //[frac1 release]; 
  59.  
  60. // release the pool and all objects in it 
  61.  
  62. [pool release]; 
  63.  
  64. return 0; 
  65.  

output

  1. Fraction 1: 2/5 
  2.  
  3. Fraction 2: 1/3 

在这个例子裡,此 method 是一个 class level method。在物件建立后,在它上面唿叫 了 autorelease。在 main method 裡面,我从未在此物件上唿叫 release。

这样行得通的塬因是:对任何 retain 而言,一定要唿叫一个 release 或 autorelease。物件的 retainCount 从 1 起跳 ,然后我在上面唿叫 1 次 autorelease,表示 1 - 1 = 0。当 autorelease pool 被释放时,它会计算所有物件上的 autorelease 唿叫次数,并且唿叫相同次数的 [obj release]。

如同註解所说,不把那一行註解掉会造成分段错误(segment fault)。因为物件上已经唿叫过 autorelease,若再唿叫 release,在释放 autorelease pool 时会试图唿叫一个 nil 物件上的 dealloc,但这是不允许的。最后的算式会变为:1 (creation) - 1 (release) - 1 (autorelease) = -1

管理大量暂时物件时,autorelease pool 可以被动态地产生。你需要做的只是建立一个 pool,执行一堆会建立大量动态物件的程式码,然后释放这个 pool。你可能会感到好奇,这表示可能同时有超过一个 autorelease pool 存在。

你可能感兴趣的:(Objective-C)