object-c 三

记忆体管理

到目前为止我都刻意避开 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

...

-(void)dealloc{

printf("Deallocingfraction\n");

[superdealloc];

}

...

main.m

#import"Fraction.h"

#import

intmain(intargc,constchar*argv[]){

Fraction*frac1=[[Fractionalloc]init];

Fraction*frac2=[[Fractionalloc]init];

//printcurrentcounts

printf("Fraction1retaincount:%i\n",[frac1retainCount]);

printf("Fraction2retaincount:%i\n",[frac2retainCount]);

//incrementthem

[frac1retain];//2

[frac1retain];//3

[frac2retain];//2

//printcurrentcounts

printf("Fraction1retaincount:%i\n",[frac1retainCount]);

printf("Fraction2retaincount:%i\n",[frac2retainCount]);

//decrement

[frac1release];//2

[frac2release];//1

//printcurrentcounts

printf("Fraction1retaincount:%i\n",[frac1retainCount]);

printf("Fraction2retaincount:%i\n",[frac2retainCount]);

//releasethemuntiltheydeallocthemselves

[frac1release];//1

[frac1release];//0

[frac2release];//0

}

output

Fraction1retaincount:1

Fraction2retaincount:1

Fraction1retaincount:3

Fraction2retaincount:2

Fraction1retaincount:2

Fraction2retaincount:1

Deallocingfraction

Deallocingfraction

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

Dealloc

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

AddressCard.h

#import

#import

@interfaceAddressCard: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*)flast:(NSString*)l;

-(void)print;

@end

AddressCard.m

#import"AddressCard.h"

#import

@implementationAddressCard

-(AddressCard*)initWithFirst:(NSString*)f

last:(NSString*)l

email:(NSString*)e{

self=[superinit];

if(self){

[selfsetFirst:flast:lemail:e];

}

returnself;

}

-(NSString*)first{

returnfirst;

}

-(NSString*)last{

returnlast;

}

-(NSString*)email{

returnemail;

}

-(void)setFirst:(NSString*)f{

[fretain];

[firstrelease];

ffirst=f;

}

-(void)setLast:(NSString*)l{

[lretain];

[lastrelease];

llast=l;

}

-(void)setEmail:(NSString*)e{

[eretain];

[emailrelease];

eemail=e;

}

-(void)setFirst:(NSString*)f

last:(NSString*)l

email:(NSString*)e{

[selfsetFirst:f];

[selfsetLast:l];

[selfsetEmail:e];

}

-(void)setFirst:(NSString*)flast:(NSString*)l{

[selfsetFirst:f];

[selfsetLast:l];

}

-(void)print{

printf("%s%s<%S>

",[firstcString],

[lastcString],

[emailcString]);

}

-(void)dealloc{

[firstrelease];

[lastrelease];

[emailrelease];

[superdealloc];

}

@end

main.m

#import"AddressCard.h"

#import

#import

intmain(intargc,constchar*argv[]){

NSString*first=[[NSStringalloc]initWithCString:"Tom"];

NSString*last=[[NSStringalloc]initWithCString:"Jones"];

NSString*email=[[NSStringalloc]initWithCString:"[email protected]"];

AddressCard*tom=[[AddressCardalloc]initWithFirst:first

last:last

email:email];

//we'redonewiththestrings,sowemustdeallocthem

[firstrelease];

[lastrelease];

[emailrelease];

//printtoshowtheretaincount

printf("Retaincount:%i\n",[[tomfirst]retainCount]);

[tomprint];

printf("\n");

//freememory

[tomrelease];

return0;

}

output

Retaincount:1

TomJones

如 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 会自动地帮你设定好。

main.m

#import

#import

#import

intmain(intargc,constchar*argv[]){

NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];

NSString*str1=@"constantstring";

NSString*str2=[NSStringstringWithString:@"stringmanagedbythepool"];

NSString*str3=[[NSStringalloc]initWithString:@"selfmanagedstring"];

//printthestrings

printf("%sretaincount:%x\n",[str1cString],[str1retainCount]);

printf("%sretaincount:%x\n",[str2cString],[str2retainCount]);

printf("%sretaincount:%x\n",[str3cString],[str3retainCount]);

//freememory

[str3release];

//freepool

[poolrelease];

return0;

}

output

constantstringretaincount:ffffffff

stringmanagedbythepoolretaincount:1

selfmanagedstringretaincount: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。

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

Fraction.h

...

+(Fraction*)fractionWithNumerator:(int)ndenominator:(int)d;

...

Fraction.m

...

+(Fraction*)fractionWithNumerator:(int)ndenominator:(int)d{

Fraction*ret=[[Fractionalloc]initWithNumerator:ndenominator:d];

[retautorelease];

returnret;

}

...

main.m

#import

#import"Fraction.h"

#import

intmain(intargc,constchar*argv[]){

NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];

Fraction*frac1=[FractionfractionWithNumerator:2denominator:5];

Fraction*frac2=[FractionfractionWithNumerator:1denominator:3];

//printfrac1

printf("Fraction1:");

[frac1print];

printf("\n");

//printfrac2

printf("Fraction2:");

[frac2print];

printf("\n");

//thiscausesasegmentationfault

//[frac1release];

//releasethepoolandallobjectsinit

[poolrelease];

return0;

}

output

Fraction1:2/5

Fraction2: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 存在。