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. -(void) dealloc {
4. printf( "Deallocing fraction\n" );
5. [super dealloc];
6. }
7. ...

1. main.m
2. #import "Fraction.h"
3. #import
4. int main( int argc, const char *argv[] ) {
5. Fraction *frac1 = [[Fraction alloc] init];
6. Fraction *frac2 = [[Fraction alloc] init];
7. // print current counts
8. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] );
9. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] );
10. // increment them
11. [frac1 retain]; // 2
12. [frac1 retain]; // 3
13. [frac2 retain]; // 2
14. // print current counts
15. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] );
16. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] );
17. // decrement
18. [frac1 release]; // 2
19. [frac2 release]; // 1
20. // print current counts
21. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] );
22. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] );
23. // release them until they dealloc themselves
24. [frac1 release]; // 1
25. [frac1 release]; // 0
26. [frac2 release]; // 0
27. }

output

1. Fraction 1 retain count: 1
2. Fraction 2 retain count: 1
3. Fraction 1 retain count: 3
4. Fraction 2 retain count: 2
5. Fraction 1 retain count: 2
6. Fraction 2 retain count: 1
7. Deallocing fraction
8. Deallocing fraction

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

Dealloc

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

AddressCard.h

1. #import
2. #import
3. @interface AddressCard: NSObject {
4. NSString *first;
5. NSString *last;
6. NSString *email;
7. }
8. -(AddressCard*) initWithFirst: (NSString*) f
9. last: (NSString*) l
10. email: (NSString*) e;
11. -(NSString*) first;
12. -(NSString*) last;
13. -(NSString*) email;
14. -(void) setFirst: (NSString*) f;
15. -(void) setLast: (NSString*) l;
16. -(void) setEmail: (NSString*) e;
17. -(void) setFirst: (NSString*) f
18. last: (NSString*) l
19. email: (NSString*) e;
20. -(void) setFirst: (NSString*) f last: (NSString*) l;
21. -(void) print;
22. @end
23. AddressCard.m
24. #import "AddressCard.h"
25. #import
26. @implementation AddressCard
27. -(AddressCard*) initWithFirst: (NSString*) f
28. last: (NSString*) l
29. email: (NSString*) e {
30. self = [super init];
31. if ( self ) {
32. [self setFirst: f last: l email: e];
33. }
34. return self;
35. }
36. -(NSString*) first {
37. return first;
38. }
39. -(NSString*) last {
40. return last;
41. }
42. -(NSString*) email {
43. return email;
44. }
45. -(void) setFirst: (NSString*) f {
46. [f retain];
47. [first release];
48. ffirst = f;
49. }
50. -(void) setLast: (NSString*) l {
51. [l retain];
52. [last release];
53. llast = l;
54. }
55. -(void) setEmail: (NSString*) e {
56. [e retain];
57. [email release];
58. eemail = e;
59. }
60. -(void) setFirst: (NSString*) f
61. last: (NSString*) l
62. email: (NSString*) e {
63. [self setFirst: f];
64. [self setLast: l];
65. [self setEmail: e];
66. }
67. -(void) setFirst: (NSString*) f last: (NSString*) l {
68. [self setFirst: f];
69. [self setLast: l];
70. }
71. -(void) print {
72. printf( "%s %s <%S>
73. ", [first cString],
74. [last cString],
75. [email cString] );
76. }
77. -(void) dealloc {
78. [first release];
79. [last release];
80. [email release];
81. [super dealloc];
82. }
83. @end
84. main.m
85. #import "AddressCard.h"
86. #import
87. #import
88. int main( int argc, const char *argv[] ) {
89. NSString *first =[[NSString alloc] initWithCString: "Tom"];
90. NSString *last = [[NSString alloc] initWithCString: "Jones"];
91. NSString *email = [[NSString alloc] initWithCString: "tom@jones.com"];
92. AddressCard *tom = [[AddressCard alloc] initWithFirst: first
93. last: last
94. email: email];
95. // we're done with the strings, so we must dealloc them
96. [first release];
97. [last release];
98. [email release];
99. // print to show the retain count
100. printf( "Retain count: %i\n", [[tom first] retainCount] );
101. [tom print];
102. printf( "\n" );
103. // free memory
104. [tom release];
105. return 0;
106. }

output

1. Retain count: 1
2. 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. #import
3. #import
4. #import
5. int main( int argc, const char *argv[] ) {
6. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
7. NSString *str1 = @"constant string";
8. NSString *str2 = [NSString stringWithString: @"string managed by the pool"];
9. NSString *str3 = [[NSString alloc] initWithString: @"self managed string"];
10. // print the strings
11. printf( "%s retain count: %x\n", [str1 cString], [str1 retainCount] );
12. printf( "%s retain count: %x\n", [str2 cString], [str2 retainCount] );
13. printf( "%s retain count: %x\n", [str3 cString], [str3 retainCount] );
14. // free memory
15. [str3 release];
16. // free pool
17. [pool release];
18. return 0;
19. }

output

1. constant string retain count: ffffffff
2. string managed by the pool retain count: 1
3. 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. +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d;
4. ...
5. Fraction.m
6. ...
7. +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d {
8. Fraction *ret = [[Fraction alloc] initWithNumerator: n denominator: d];
9. [ret autorelease];
10. return ret;
11. }
12. ...
13. main.m
14. #import
15. #import "Fraction.h"
16. #import
17. int main( int argc, const char *argv[] ) {
18. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
19. Fraction *frac1 = [Fraction fractionWithNumerator: 2 denominator: 5];
20. Fraction *frac2 = [Fraction fractionWithNumerator: 1 denominator: 3];
21. // print frac 1
22. printf( "Fraction 1: " );
23. [frac1 print];
24. printf( "\n" );
25. // print frac 2
26. printf( "Fraction 2: " );
27. [frac2 print];
28. printf( "\n" );
29. // this causes a segmentation fault
30. //[frac1 release];
31. // release the pool and all objects in it
32. [pool release];
33. return 0;
34. }

output

1. Fraction 1: 2/5
2. 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 存在。