Objective-c 深浅拷贝

最新推荐文章于 2023-10-07 14:20:26 发布

SarahZuo

最新推荐文章于 2023-10-07 14:20:26 发布

阅读量424

点赞数

分类专栏： Objective-c

Objective-c 专栏收录该内容

6 篇文章

订阅专栏

（转自http://woshao.com/article/f91898b24a1211e097d3000c 2959fd2a/）

在ObjC中，什么是深浅拷贝？
深浅拷贝分别指深拷贝和浅拷贝，即mutableCopy和copy方法。
copy复制一个不可变对象，而mutableCopy复制一个mutable可变对象。

什么时候用到深浅拷贝？下面举几个例子说明。

非容器类对象

如NSString，NSNumber等一类对象
示例1：


1   // 非容器类对象
2     NSString *str = @"origin string";
3     NSString *strCopy = [str copy];
4     NSMutableString *mstrCopy = [str mutableCopy];
5     [mstrCopy appendString:@"??"];

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

示例2：


1 NSMutableString *mstr = [NSMutableString stringWithString:@"origin"];
2     NSString *strCopy = [mstr copy];
3     NSMutableString *mstrCopy = [mstr copy];
4     NSMutableString *mstrMCopy = [mstr mutableCopy];
5     //[mstrCopy appendString:@"1111"];  //error
6     [mstr appendString:@"222"];
7     [mstrMCopy appendString:@"333"];

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

小结：
对于非容器类对象，有：

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

或者自己总结的，对于非容器类对象：

mutablecopy都会返回一个可变对象，所以都是深拷贝。
copy都会返回一个不可变对象，所以如果原来是不可变的则不会新建，如果原来是可变的则需要新建一个对象。即不耽误原则。

容器类对象深浅复制

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

示例3


 1    
 2    
 3     NSArray *array1     = [NSArray arrayWithObjects:@"a",@"b",@"c",nil];
 4     NSArray *arrayCopy1 = [array1 copy];
 5     //arrayCopy1是和array同一个NSArray对象（指向相同的对象），包括array里面的元素也是指向相同的指针
 6     NSLog(@"array1 retain count: %d",[array1 retainCount]);
 7     NSLog(@"array1 retain count: %d",[arrayCopy1 retainCount]);
 8    
 9     NSMutableArray *mArrayCopy1 = [array1 mutableCopy];
10     //mArrayCopy1是array1的可变副本，指向的对象和array1不同，但是其中的元素和array1中的元素指向的还是同一个对象。mArrayCopy1还可以修改自己的对象
11     [mArrayCopy1 addObject:@"de"];
12     [mArrayCopy1 removeObjectAtIndex:0];

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

示例4


 1   NSArray *mArray1 = [NSArray arrayWithObjects:[NSMutableString stringWithString:@"a"],@"b",@"c",nil];
 2     NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);
 3     NSArray *mArrayCopy2 = [mArray1 copy];
 4     NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);
 5     // mArray1和mArrayCopy2指向同一对象，retain值+1。
 6    
 7     NSMutableArray *mArrayMCopy1 = [mArray1 mutableCopy];
 8     NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);
 9     //mArrayCopy2和mArray1指向的是不一样的对象，但是其中的元素都是一样的对象——同一个指针
10 
11     NSMutableString *testString = [mArray1 objectAtIndex:0];
12     //testString = @"1a1";//这样会改变testString的指针，其实是将@“1a1”临时对象赋给了testString
13     [testString appendString:@" tail"];//这样以上三个数组的首元素都被改变了

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

示例5


1     NSArray *array = [NSArray arrayWithObjects:[NSMutableString stringWithString:@"first"],[NSStringstringWithString:@"b"],@"c",nil];
2     NSArray *deepCopyArray=[[NSArray alloc] initWithArray: array copyItems: YES];
3     NSArray* trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:
4     [NSKeyedArchiver archivedDataWithRootObject: array]];

trueDeepCopyArray是完全意义上的深拷贝，而deepCopyArray则不是，对于deepCopyArray内的不可变元素其还是指针复制。
或者我们自己实现深拷贝的方法。因为如果容器的某一元素是不可变的，那你复制完后该对象仍旧是不能改变的，因此只需要指针复制即可。除非你对容器内的元素重新赋值，否则指针复制即已足够。
举个例子，[[arrayobjectAtIndex:0]appendstring:@”sd”]后其他的容器内对象并不会受影响。[[arrayobjectAtIndex:1]和[[deepCopyArrayobjectAtIndex:0]尽管是指向同一块内存，但是我们没有办法对其进行修改——因为它是不可改变的。所以指针复制已经足够。所以这并不是完全意义上的深拷贝。

自己实现深拷贝的方法

NSDictionaryMutableDeepCopy.h


1 #import <</span>foundation /Foundation.h>
2 
3 @interface NSDictionary(MutableDeepCopy)
4 
5 - (NSMutableDictionary *)mutableDeepCopy;
6 
7 @end

NSDictionaryMutableDeepCopy.m


 1 #import "NSDictionaryMutableDeepCopy.h"
 2 
 3 
 4 @implementation NSDictionary(MutableDeepCopy)
 5 
 6 - (NSMutableDictionary *)mutableDeepCopy {
 7     NSMutableDictionary *ret = [[NSMutableDictionary alloc]
 8                                 initWithCapacity:[self count]];
 9     NSArray *keys = [self allKeys];
10     for (id key in keys) {
11         id oneValue = [self valueForKey:key];
12         id oneCopy = nil;
13        
14         if ([oneValue respondsToSelector:@selector(mutableDeepCopy)]) {
15             oneCopy = [oneValue mutableDeepCopy];
16         }
17         else if ([oneValue respondsToSelector:@selector(mutableCopy)]) {
18             oneCopy = [oneValue mutableCopy];
19         }
20         if (oneCopy == nil) {
21             oneCopy = [oneValue copy];
22         }
23         [ret setValue:oneCopy forKey:key];
24     }
25    
26     return ret;
27 }
28 
29 @end

使用类别方法来实现。

自定义对象

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


 1 @interface MyObj : NSObject<</span>nscopying ,NSMutableCopying>
 2 {
 3          NSMutableString *name;
 4          NSString *imutableStr;
 5          int age;
 6 }
 7 @property (nonatomic, retain) NSMutableString *name;
 8 @property (nonatomic, retain) NSString *imutableStr;
 9 @property (nonatomic) int age;
10  
11 @end
12  
13 @implementation MyObj
14 @synthesize name;
15 @synthesize age;
16 @synthesize imutableStr;
17 - (id)init
18 {
19          if (self = [super init])
20          {
21                    self.name = [[NSMutableString alloc]init];
22                    self.imutableStr = [[NSString alloc]init];
23                    age = -1;
24          }
25          return self;
26 }
27  
28 - (void)dealloc
29 {
30          [name release];
31          [imutableStr release];
32          [super dealloc];
33 }
34 - (id)copyWithZone:(NSZone *)zone
35 {
36          MyObj *copy = [[[self class] allocWithZone:zone] init];
37          copy->name = [name copy];
38          copy->imutableStr = [imutableStr copy];
39 //       copy->name = [name copyWithZone:zone];;
40 //       copy->imutableStr = [name copyWithZone:zone];//
41          copy->age = age;
42  
43          return copy;
44 }
45 - (id)mutableCopyWithZone:(NSZone *)zone
46 {
47          MyObj *copy = NSCopyObject(self, 0, zone);
48          copy->name = [self.name mutableCopy];
49          copy->age = age;
50          return copy;
51 }
52 @end
53 </</span>nscopying