ObjectiveC 深浅拷贝(mutableDeepCopy)学习

在ObjectiveC 中，什么是深浅拷贝？深浅拷贝分别指深拷贝和浅拷贝，即mutableCopy和copy方法。

copy复制一个不可变对象，而mutableCopy复制一个mutable可变对象。

什么时候用到深浅拷贝？下面举几个例子说明。非容器类对象如NSString，NSNumber等一类对象

示例1：

//非容器类对象NSString*str=@"originstring";
NSString*strCopy=[strcopy];
NSMutableString*mstrCopy=[strmutableCopy];
[mstrCopyappendString:@"??"];

查看内存可以发现，str和strCopy指向的是同一块内存区域，我们称之为弱引用（weak reference）。而mstrCopy是真正的复制，系统为其分配了新内存空间，保存从str复制过来的字符串值。从最后一行代码中修改这些值而不影响str和strCopy中可证明。

示例2：

NSMutableString*mstr=[NSMutableStringstringWithString:@"origin"];
NSString*strCopy=[mstrcopy];
NSMutableString*mstrCopy=[mstrcopy];
NSMutableString*mstrMCopy=[mstrmutableCopy];
//[mstrCopyappendString:@"1111"];//error
[mstrappendString:@"222"];
[mstrMCopyappendString:@"333"];

以上四个对象所分配的内存都是不一样的。而且对于mstrCopy，它所指向的其实是一个imutable对象，是不可改变的，所以会出错。这点要注意，好好理解。

容器类对象深浅复制

比如NSArray，NSDictionary等。对于容器类本身，上面讨论的结论也适用的，下面探讨的是复制后容器内对象的变化。

示例3

/*copy返回不可变对象，mutablecopy返回可变对象*/


NSArray*array1=[NSArrayarrayWithObjects:@"a",@"b",@"c",nil];
NSArray*arrayCopy1=[array1copy];
//arrayCopy1是和array同一个NSArray对象（指向相同的对象），包括array里面的元素也是指向相同的指针
NSLog(@"array1retaincount:%d",[array1retainCount]);
NSLog(@"array1retaincount:%d",[arrayCopy1retainCount]);

NSMutableArray*mArrayCopy1=[array1mutableCopy];
//mArrayCopy1是array1的可变副本，指向的对象和array1不同，但是其中的元素和array1中的元素指向的还是同一个对象。mArrayCopy1还可以修改自己的对象
[mArrayCopy1addObject:@"de"];
[mArrayCopy1removeObjectAtIndex:0];

array1和arrayCopy1是指针复制，而mArrayCopy1是对象复制，符合前面示例1讨论的结论。mArrayCopy1可以改变其内的元素：删除或添加。但容器内的元素内容都是浅拷贝。

示例4

NSArray*mArray1=[NSArrayarrayWithObjects:[NSMutableStringstringWithString:@"a"],@"b",@"c",nil];
NSLog(@"mArray1retaincount:%d",[mArray1retainCount]);
NSArray*mArrayCopy2=[mArray1copy];
NSLog(@"mArray1retaincount:%d",[mArray1retainCount]);
//mArray1和mArrayCopy2指向同一对象，retain值+1。

NSMutableArray*mArrayMCopy1=[mArray1mutableCopy];
NSLog(@"mArray1retaincount:%d",[mArray1retainCount]);//mArrayCopy2和mArray1指向的是不一样的对象，但是其中的元素都是一样的对象——同一个指针

NSMutableString*testString=[mArray1objectAtIndex:0];

//testString=@"1a1";//这样会改变testString的指针，其实是将@“1a1”临时对象赋给了testString
[testStringappendString:@"tail"];//这样以上三个数组的首元素都被改变了

由此可见，对于容器而言，其元素对象始终是指针复制。如果需要元素对象也是对象复制，就需要实现深拷贝。http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Collections/Articles/Copying.html

示例5

NSArray*array=[NSArrayarrayWithObjects:[NSMutableStringstringWithString:@"first"],[NSStringstringWithString:@"b"],@"c",nil];
NSArray*deepCopyArray=[[NSArrayalloc]initWithArray:arraycopyItems:YES];
NSArray*trueDeepCopyArray=[NSKeyedUnarchiverunarchiveObjectWithData:
[NSKeyedArchiverarchivedDataWithRootObject:array]];

trueDeepCopyArray是完全意义上的深拷贝，而deepCopyArray则不是，对于deepCopyArray内的不可变元素其还是指针复制。

或者我们自己实现深拷贝的方法。因为如果容器的某一元素是不可变的，那你复制完后该对象仍旧是不能改变的，因此只需要指针复制即可。除非你对容器内的元素重新赋值，否则指针复制即已足够。

举个例子，[[array objectAtIndex:0]appendstring:@”sd”]后其他的容器内对象并不会受影响。[[array objectAtIndex:1]和[[deepCopyArray

objectAtIndex:0]尽管是指向同一块内存，但是我们没有办法对其进行修改——因为它是不可改变的。所以指针复制已经足够。所以这并不是完全意义上的深拷贝。

自己实现深拷贝的方法

NSDictionaryMutableDeepCopy.h

8#import<foundation/Foundation.h>
@interfaceNSDictionary(MutableDeepCopy)
-(NSMutableDictionary*)mutableDeepCopy;
@end
</foundation>
NSDictionaryMutableDeepCopy.m
#import"NSDictionaryMutableDeepCopy.h"
@implementationNSDictionary(MutableDeepCopy)
-(NSMutableDictionary*)mutableDeepCopy{
NSMutableDictionary*ret=[[NSMutableDictionaryalloc]
initWithCapacity:[selfcount]];
NSArray*keys=[selfallKeys];
for(idkeyinkeys){
idoneValue=[selfvalueForKey:key];
idoneCopy=nil;
if([oneValuerespondsToSelector:@selector(mutableDeepCopy)]){
oneCopy=[oneValuemutableDeepCopy];
}
elseif([oneValuerespondsToSelector:@selector(mutableCopy)]){
oneCopy=[oneValuemutableCopy];
}
if(oneCopy==nil){
oneCopy=[oneValuecopy];
}
[retsetValue:oneCopyforKey:key];
}
returnret;
}
@end

使用类别方法来实现。

自定义对象

如果是我们定义的对象，那么我们自己要实现NSCopying,NSMutableCopying这样就能调用copy和mutablecopy了。举个例子：

@interfaceMyObj:NSObject<nscopying,NSMutableCopying>
{
NSMutableString*name;
NSString*imutableStr;
intage;
}
@property(nonatomic,retain)NSMutableString*name;
@property(nonatomic,retain)NSString*imutableStr;
@property(nonatomic)intage;

@end

@implementationMyObj
@synthesizename;
@synthesizeage;
@synthesizeimutableStr;
-(id)init
{
if(self=[superinit])
{
self.name=[[NSMutableStringalloc]init];
self.imutableStr=[[NSStringalloc]init];
age=-1;
}
returnself;
}
-(void)dealloc
{
[namerelease];
[imutableStrrelease];
[superdealloc];
}
-(id)copyWithZone:(NSZone*)zone
{
MyObj*copy=[[[selfclass]allocWithZone:zone]init];
copy->name=[namecopy];
copy->imutableStr=[imutableStrcopy];
//copy->name=[namecopyWithZone:zone];;
//copy->imutableStr=[namecopyWithZone:zone];//
copy->ageage=age;

returncopy;
}
-(id)mutableCopyWithZone:(NSZone*)zone
{
MyObj*copy=NSCopyObject(self,0,zone);
copy->name=[self.namemutableCopy];
copy->ageage=age;
returncopy;
}
@end
</nscopying>

小结：

对于非容器类对象，有：

如果对一个不可变对象复制，copy是指针复制，即浅拷贝；而mutableCopy则是对象复制，即深拷贝。（示例1）

如果是对可变对象复制，都是深拷贝，但copy复制返回的对象是不可变的。（示例2）

转载自：http://mobile.51cto.com/iphone-267060.htm