- 内存管理
- 到目前为止我都刻意避开 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。
- Fraction.m
- 到目前为止我都刻意避开 Objective-C 的内存管理议题。你可以呼叫对象上的 dealloc，但是若对象里包含其它对象的指针的话，要怎么办呢？要释放那些对象所占据的内存也是一个必须关注的问题。当你使用 Foundation framework 建立 classes 时，它如何管理内存？这些稍后我们都会解释。
§ ...
§ -(void) dealloc {
§ printf( "Deallocing fraction\n" );
§ [super dealloc];
§ }
...
- 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
- main.m
§ #import "Fraction.h"
§ #import <stdio.h>
§
§ int main( int argc, const char *argv[] ) {
§ Fraction *frac1 = [[Fraction alloc] init];
§ Fraction *frac2 = [[Fraction alloc] init];
§
§ // print current counts
§ printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] );
§ printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] );
§
§ // increment them
§ [frac1 retain]; // 2
§ [frac1 retain]; // 3
§ [frac2 retain]; // 2
§
§ // print current counts
§ printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] );
§ printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] );
§
§ // decrement
§ [frac1 release]; // 2
§ [frac2 release]; // 1
§
§ // print current counts
§ printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] );
§ printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] );
§
§ // release them until they dealloc themselves
§ [frac1 release]; // 1
§ [frac1 release]; // 0
§ [frac2 release]; // 0
}
- output
§ Fraction 1 retain count: 1
§ Fraction 2 retain count: 1
§ Fraction 1 retain count: 3
§ Fraction 2 retain count: 2
§ Fraction 1 retain count: 2
§ Fraction 2 retain count: 1
§ Deallocing fraction
Deallocing fraction
- Retain call 增加计数器值，而 release call 减少它。你可以呼叫 [obj retainCount] 来取得计数器的 int 值。 当当 retainCount 到达 0，两个对象都会 dealloc 自己，所以可以看到印出了两个 "Deallocing fraction"。
- Dealloc
- 当你的对象包含其它对象时，就得在 dealloc 自己时释放它们。Objective-C 的一个优点是你可以传递讯息给 nil，所以不需要经过一堆防错测试来释放一个对象。
- 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
- AddressCard.h
§ #import <Foundation/NSObject.h>
§ #import <Foundation/NSString.h>
§
§ @interface AddressCard: NSObject {
§ NSString *first;
§ NSString *last;
§ NSString *email;
§ }
§
§ -(AddressCard*) initWithFirst: (NSString*) f
§ last: (NSString*) l
§ email: (NSString*) e;
§ -(NSString*) first;
§ -(NSString*) last;
§ -(NSString*) email;
§ -(void) setFirst: (NSString*) f;
§ -(void) setLast: (NSString*) l;
§ -(void) setEmail: (NSString*) e;
§ -(void) setFirst: (NSString*) f
§ last: (NSString*) l
§ email: (NSString*) e;
§ -(void) setFirst: (NSString*) f last: (NSString*) l;
§ -(void) print;
@end
- AddressCard.m
§ #import "AddressCard.h"
§ #import <stdio.h>
§
§ @implementation AddressCard
§ -(AddressCard*) initWithFirst: (NSString*) f
§ last: (NSString*) l
§ email: (NSString*) e {
§ self = [super init];
§
§ if ( self ) {
§ [self setFirst: f last: l email: e];
§ }
§
§ return self;
§ }
§
§ -(NSString*) first {
§ return first;
§ }
§
§ -(NSString*) last {
§ return last;
§ }
§
§ -(NSString*) email {
§ return email;
§ }
§
§ -(void) setFirst: (NSString*) f {
§ [f retain];
§ [first release];
§ first = f;
§ }
§
§ -(void) setLast: (NSString*) l {
§ [l retain];
§ [last release];
§ last = l;
§ }
§
§ -(void) setEmail: (NSString*) e {
§ [e retain];
§ [email release];
§ email = e;
§ }
§
§ -(void) setFirst: (NSString*) f
§ last: (NSString*) l
§ email: (NSString*) e {
§ [self setFirst: f];
§ [self setLast: l];
§ [self setEmail: e];
§ }
§
§ -(void) setFirst: (NSString*) f last: (NSString*) l {
§ [self setFirst: f];
§ [self setLast: l];
§ }
§
§ -(void) print {
§ printf( "%s %s <%s>", [first cString],
§ [last cString],
§ [email cString] );
§ }
§
§ -(void) dealloc {
§ [first release];
§ [last release];
§ [email release];
§
§ [super dealloc];
§ }
@end
- main.m
§ #import "AddressCard.h"
§ #import <Foundation/NSString.h>
§ #import <stdio.h>
§
§ int main( int argc, const char *argv[] ) {
§ NSString *first =[[NSString alloc] initWithCString: "Tom"];
§ NSString *last = [[NSString alloc] initWithCString: "Jones"];
§ NSString *email = [[NSString alloc] initWithCString: "tom@jones.com"];
§ AddressCard *tom = [[AddressCard alloc] initWithFirst: first
§ last: last
§ email: email];
§
§ // we're done with the strings, so we must dealloc them
§ [first release];
§ [last release];
§ [email release];
§
§ // print to show the retain count
§ printf( "Retain count: %i\n", [[tom first] retainCount] );
§ [tom print];
§ printf( "\n" );
§
§ // free memory
§ [tom release];
§
§ return 0;
}
- output
§ Retain count: 1
Tom Jones <tom@jones.com>
- 如 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 会自动地帮你设定好。
- 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
- main.m
§ #import <Foundation/NSString.h>
§ #import <Foundation/NSAutoreleasePool.h>
§ #import <stdio.h>
§
§ int main( int argc, const char *argv[] ) {
§ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
§ NSString *str1 = @"constant string";
§ NSString *str2 = [NSString stringWithString: @"string managed by the pool"];
§ NSString *str3 = [[NSString alloc] initWithString: @"self managed string"];
§
§ // print the strings
§ printf( "%s retain count: %x\n", [str1 cString], [str1 retainCount] );
§ printf( "%s retain count: %x\n", [str2 cString], [str2 retainCount] );
§ printf( "%s retain count: %x\n", [str3 cString], [str3 retainCount] );
§
§ // free memory
§ [str3 release];
§
§ // free pool
§ [pool release];
§ return 0;
}
- output
§ constant string retain count: ffffffff
§ string managed by the pool retain count: 1
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。
- 下一个范例会展示我说的这点。
- 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
- Fraction.h
§ ...
§ +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d;
§ ...
- Fraction.m
§ ...
§ +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d {
§ Fraction *ret = [[Fraction alloc] initWithNumerator: n denominator: d];
§ [ret autorelease];
§
§ return ret;
§ }
...
- main.m
§ #import <Foundation/NSAutoreleasePool.h>
§ #import "Fraction.h"
§ #import <stdio.h>
§
§ int main( int argc, const char *argv[] ) {
§ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
§ Fraction *frac1 = [Fraction fractionWithNumerator: 2 denominator: 5];
§ Fraction *frac2 = [Fraction fractionWithNumerator: 1 denominator: 3];
§
§ // print frac 1
§ printf( "Fraction 1: " );
§ [frac1 print];
§ printf( "\n" );
§
§ // print frac 2
§ printf( "Fraction 2: " );
§ [frac2 print];
§ printf( "\n" );
§
§ // this causes a segmentation fault
§ //[frac1 release];
§
§ // release the pool and all objects in it
§ [pool release];
§ return 0;
}
- output
§ Fraction 1: 2/5
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 存在。
- Foundation framework classes
- Foundation framework 地位如同 C++ 的 Standard Template Library。不过 Objective-C 是真正的动态识别语言（dynamic types），所以不需要像 C++ 那样肥得可怕的样版（templates）。这个 framework 包含了对象组、网络、执行绪，还有更多好东西。
- NSArray
- 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
- main.m
§ #import <Foundation/NSArray.h>
§ #import <Foundation/NSString.h>
§ #import <Foundation/NSAutoreleasePool.h>
§ #import <Foundation/NSEnumerator.h>
§ #import <stdio.h>
§
§ void print( NSArray *array ) {
§ NSEnumerator *enumerator = [array objectEnumerator];
§ id obj;
§
§ while ( obj = [enumerator nextObject] ) {
§ printf( "%s\n", [[obj description] cString] );
§ }
§ }
§
§ int main( int argc, const char *argv[] ) {
§ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
§ NSArray *arr = [[NSArray alloc] initWithObjects:
§ @"Me", @"Myself", @"I", nil];
§ NSMutableArray *mutable = [[NSMutableArray alloc] init];
§
§ // enumerate over items
§ printf( "----static array\n" );
§ print( arr );
§
§ // add stuff
§ [mutable addObject: @"One"];
§ [mutable addObject: @"Two"];
§ [mutable addObjectsFromArray: arr];
§ [mutable addObject: @"Three"];
§
§ // print em
§ printf( "----mutable array\n" );
§ print( mutable );
§
§ // sort then print
§ printf( "----sorted mutable array\n" );
§ [mutable sortUsingSelector: @selector( caseInsensitiveCompare: )];
§ print( mutable );
§
§ // free memory
§ [arr release];
§ [mutable release];
§ [pool release];
§
§ return 0;
}
- output
§ ----static array
§ Me
§ Myself
§ I
§ ----mutable array
§ One
§ Two
§ Me
§ Myself
§ I
§ Three
§ ----sorted mutable array
§ I
§ Me
§ Myself
§ One
§ Three
Two
- 数组有两种（通常是 Foundation classes 中最数据导向的部分），NSArray 跟 NSMutableArray，顾名思义，mutable（善变的）表示可以被改变，而 NSArray 则不行。这表示你可以制造一个 NSArray 但却不能改变它的长度。
- 你可以用 Obj, Obj, Obj, ..., nil 为参数呼叫建构子来初始化一个数组，其中 nil 表示结尾符号。
- 排序（sorting）展示如何用 selector 来排序一个对象，这个 selector 告诉数组用 NSString 的忽略大小写顺序来排序。如果你的对象有好几个排序方法，你可以使用这个 selector 来选择你想用的方法。
- 在 print method 里，我使用了 description method。它就像 Java 的 toString，会回传对象的 NSString 表示法。
- NSEnumerator 很像 Java 的列举系统。while ( obj = [array objectEnumerator] ) 行得通的理由是 objectEnumerator 会回传最后一个对象的 nil。在 C 里 nil 通常代表 0，也就是 false。改用 ( ( obj = [array objectEnumerator] ) != nil ) 也许更好。
- NSDictionary
- 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
- main.m
§ #import <Foundation/NSString.h>
§ #import <Foundation/NSAutoreleasePool.h>
§ #import <Foundation/NSDictionary.h>
§ #import <Foundation/NSEnumerator.h>
§ #import <Foundation/Foundation.h<
§ #import <stdio.h>
§
§ void print( NSDictionary *map ) {
§ NSEnumerator *enumerator = [map keyEnumerator];
§ id key;
§
§ while ( key = [enumerator nextObject] ) {
§ printf( "%s => %s\n",
§ [[key description] cString],
§ [[[map objectForKey: key] description] cString] );
§ }
§ }
§
§ int main( int argc, const char *argv[] ) {
§ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
§ NSDictionary *dictionary = [[NSDictionary alloc] initWithObjectsAndKeys:
§ @"one", [NSNumber numberWithInt: 1],
§ @"two", [NSNumber numberWithInt: 2],
§ @"three", [NSNumber numberWithInt: 3],
§ nil];
§ NSMutableDictionary *mutable = [[NSMutableDictionary alloc] init];
§
§ // print dictionary
§ printf( "----static dictionary\n" );
§ print( dictionary );
§
§ // add objects
§ [mutable setObject: @"Tom" forKey: @"tom@jones.com"];
§ [mutable setObject: @"Bob" forKey: @"bob@dole.com" ];
§
§ // print mutable dictionary
§ printf( "----mutable dictionary\n" );
§ print( mutable );
§
§ // free memory
§ [dictionary release];
§ [mutable release];
§ [pool release];
§
§ return 0;
}
- output
§ ----static dictionary
§ 1 => one
§ 2 => two
§ 3 => three
§ ----mutable dictionary
§ bob@dole.com => Bob
tom@jones.com => Tom
- 优点与缺点
- 优点
- Cateogies
- Posing
- 动态识别
- 指标计算
- 弹性讯息传递
- 不是一个过度复杂的 C 衍生语言
- 可透过 Objective-C++ 与 C++ 结合
- 缺点
- 不支持命名空间
- 不支持运算子多载（虽然这常常被视为一个优点，不过正确地使用运算子多载可以降低程序代码复杂度）
- 语言里仍然有些讨厌的东西，不过不比 C++ 多。
- 优点
- 更多信息
89
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
