浅拷贝(Shallow Copy)与深拷贝(Deep Copy)

2016-04-07 本文已影响1729人 LeoAu

概念

在Objective-C中并不是所有的对象都支持Copy，MutableCopy，遵守NSCopying协议的类才可以发送Copy消息，遵守NSMutableCopying 协议的类才可以发送MutableCopy消息.

关于对象拷贝有两种方式：浅拷贝(Shallow Copy)和深拷贝(Deep Copy)。顾名思义，浅拷贝，并不拷贝对象本身，仅仅是拷贝指向对象的指针；深拷贝是直接拷贝整个对象内存到另一块内存中。
如下图：

图片

再简单些说：浅拷贝就是指针拷贝；深拷贝就是内容拷贝。

浅拷贝

这里有几种方法可以进行浅拷贝，当你创建浅拷贝的时候，在原始集合里的对象就会发送retain消息，引用计数器加1，然后再拷贝指针到新的集合对象中。

NSArray *shallowCopyArray = [someArray copyWithZone:nil];

NSDictionary *shallowCopyDict = [[NSDictionary alloc] initWithDictionary:someDictionary copyItems:NO];

深拷贝

深拷贝有两种方法，

一种是initWithArray:copyItems:，将第二个参数设置为YES，则可以执行深拷贝，如：

NSDictionary shallowCopyDict = [[NSDictionary alloc] initWithDictionary:someDictionary copyItems:YES];

NSArray array = [[NSArray alloc] initWithArray:someArray copyItems:YES];

如果使用这种方式进行深拷贝的话，则集合里每个对象元素都会收到copyWithZone:的消息，对象元素必须遵循NSCopying协议，如果没有遵循NSCopying协议的话，则运行时会发生报错。

第二个方法是将集合进行归档(archive)，然后解档(unarchive)，如：

NSArray *trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject:oldArray]];

这里需要注意：

第一种方式copyWithZone:这种拷贝方式只能够提供一层内存拷贝(one-level-deep copy)，而非真正的深拷贝。
第二种方式归档和解档才是实现真正的深拷贝。

集合单层深拷贝（one-level-deep copy）

看到这里，有同学会问：如果在多层数组中，对第一层进行内容拷贝，其它层进行指针拷贝，这种情况是属于深拷贝，还是浅拷贝？对此，苹果官网文档有这样一句话描述

This kind of copy is only capable of producing a one-level-deep copy. If you only need a one-level-deep copy...

If you need a true deep copy, such as when you have an array of arrays,you can archive and then unarchive the collection

关于浅拷贝、深拷贝、单层深拷贝做了概念区分：

浅拷贝(shallow copy)： 在浅拷贝操作时，对于被拷贝对象的每一层都是指针拷贝。

深拷贝(one-level-deep copy)：在深拷贝操作时，对于被拷贝对象，至少有一层是深拷贝。

完全拷贝(real-deep copy)：在完全拷贝操作时，对于被拷贝对象的每一层都是对象拷贝。

当然，这些都是概念性的东西，没有必要纠结于此。只要知道进行拷贝操作时，被拷贝的是指针还是内容即可。

浅拷贝实验

首先创建Person.h和Person.m,记得需要实现<NSCopying>协议

#Person.h

@interface Person : NSObject <NSCopying>

@property (nonatomic,copy) NSString *name;

@end

#Person.m

@implementation Person

@synthesize name;

//实现copyWithZone方法
- (id)copyWithZone:(NSZone *)zone {
    Person *p = [[self class] allocWithZone:zone];
    p.name = [self name];
    return p;
}

@end

浅拷贝 测试代码如下：

//创建Person对象
Person *person = [[Person alloc] init];
[person setName:@"leo"];

NSArray *array1 = [[NSArray alloc] initWithObjects:person, nil];
NSArray *array2 = [[NSArray alloc] initWithArray:array1];

[p setName:@"lily"];//尝试更改name的值

//获取两个数组里的各自Person对象
Person *p1 = [array1 objectAtIndex:0];
Person *p2 = [array2 objectAtIndex:0];
    
NSLog(@"array1:%p",array1);
NSLog(@"array2:%p",array2);
    
NSLog(@"p1:%p",p1);
NSLog(@"p2:%p",p2);
    
NSLog(@"p1.name:%@",p1.name);
NSLog(@"p2.name:%@",p2.name);

//打印结果
2016-04-07 03:14:46.964 test[29178:5181526] array1:0x7fd91a644420
2016-04-07 03:14:46.964 test[29178:5181526] array2:0x7fd91a657ed0
2016-04-07 03:14:46.964 test[29178:5181526] p1:0x7fd91a6a04d0
2016-04-07 03:14:46.964 test[29178:5181526] p2:0x7fd91a6a04d0
2016-04-07 03:14:46.964 test[29178:5181526] p1.name:lily
2016-04-07 03:14:46.964 test[29178:5181526] p2.name:lily

从打印出来的Log可以看到array1和array2的地址发生改变，但在两个数组内的Person对象是指向同一个内存地址，当name的值发生改变,两个数组内的Person对象的name同时也发生改变。

深拷贝实验

深拷贝测试代码如下

//创建Person对象
Person *person = [[Person alloc] init];
[person setName:@"leo"];

NSArray *array1 = [[NSArray alloc] initWithObjects:person, nil];

//注意仅仅是这里更改为了[[NSArray alloc] initWithArray:array1 copyItems:YES];
NSArray *array2 = [[NSArray alloc] initWithArray:array1 copyItems:YES];

[p setName:@"lily"];//尝试更改name的值

//获取两个数组里的各自Person对象
Person *p1 = [array1 objectAtIndex:0];
Person *p2 = [array2 objectAtIndex:0];
    
NSLog(@"array1:%p",array1);
NSLog(@"array2:%p",array2);
    
NSLog(@"p1:%p",p1);
NSLog(@"p2:%p",p2);
    
NSLog(@"p1.name:%@",p1.name);
NSLog(@"p2.name:%@",p2.name);

//打印结果
2016-04-07 03:27:38.173 test[29303:5192608] array1:0x7fa7e8442200
2016-04-07 03:27:38.173 test[29303:5192608] array2:0x7fa7e8442220
2016-04-07 03:27:38.173 test[29303:5192608] p1:0x7fa7e84815c0
2016-04-07 03:27:38.173 test[29303:5192608] p2:0x7fa7e847d490
2016-04-07 03:27:38.173 test[29303:5192608] p1.name:lily
2016-04-07 03:27:38.174 test[29303:5192608] p2.name:leo

从Log我们可以看出，不但array1和array2的内存地址发生改变，连array2里面的Person对象也发生改变，生成了另外一个Person对象，即使属于array1的Person对象的元素name发生改变也不会影响到array2里的Person对象。

关于对象属性的修饰符"copy"与"strong"

关于对象属性的修饰符copy与strong的不同，以下会举例子说明：

#Person.h

@interface Person : NSObject <NSCopying>

@property (nonatomic,copy) NSString *name;//这里我们定义为copy

@end

//创建一个可变字符串对象
NSMutableString *mutableString = [[NSMutableString alloc] initWithString:@"hello"];
    
Person *p = [[Person alloc] init];
[p setName:mutableString];

[mutableString appendString:@" world!"];//更改mutableString的内容

NSLog(@"p.name:%@",p.name);

//打印结果
2016-04-07 03:49:02.828 test[29679:5209081] p.name:hello

这里我们发现当可变字符串mutableString改变内容的时候，name没有发生改变,说明这里是的copy将mutableString进行"内容拷贝"

#Person.h

@interface Person : NSObject <NSCopying>

@property (nonatomic,strong) NSString *name;//这里我们定义为strong

@end

//创建一个可变字符串对象
NSMutableString *mutableString = [[NSMutableString alloc] initWithString:@"hello"];
    
Person *p = [[Person alloc] init];
[p setName:mutableString];

[mutableString appendString:@" world!"];//更改mutableString的内容

NSLog(@"p.name:%@",p.name);

//打印结果
2016-04-07 03:49:02.828 test[29679:5209081] p.name:hello world!

当将copy改为strong后发现可变字符串mutableString更改内容后，会直接影响到name的值，说明strong是对mutableString进行指针复制，然后引用计数器加1

最后我们得出的结论

一般情况下对象属性NSString的修饰符设置为copy,因为这样是防止可变字符串更改自身的值的时候不会影响到对象属性NSString的值

其实不只是NSString，包括NSArray,NSDictionary都建议设置成copy

系统对象的copy与mutableCopy方法

不管是集合类对象，还是非集合类对象，接收到copy和mutableCopy消息时，都遵循以下准则：

copy返回imutable对象；所以，如果对copy返回值使用mutable对象接口就会crash；
mutableCopy返回mutable对象；
下面将针对非集合类对象和集合类对象的copy和mutableCopy方法进行具体的阐述

1、非集合类对象的copy与mutableCopy

系统非集合类对象指的是 NSString, NSNumber ... 之类的对象。下面先看个非集合类immutable对象拷贝的例子

NSString *string = @"origin";
NSString *stringCopy = [string copy];
NSMutableString *stringMCopy = [string mutableCopy];

通过查看内存，可以看到 stringCopy 和 string 的地址是一样，进行了指针拷贝；而 stringMCopy 的地址和 string 不一样，进行了内容拷贝；

再看mutable对象拷贝例子

NSMutableString *string = [NSMutableString stringWithString: @"origin"];
//copy
NSString *stringCopy = [string copy];
NSMutableString *mStringCopy = [string copy];
NSMutableString *stringMCopy = [string mutableCopy];

//change value
[mStringCopy appendString:@"mm"]; //crash
[string appendString:@" origion!"];
[stringMCopy appendString:@"!!"];

运行以上代码，会在第7行crash，原因就是 copy 返回的对象是 immutable 对象。注释第7行后再运行，查看内存，发现 string、stringCopy、mStringCopy、stringMCopy 四个对象的内存地址都不一样，说明此时都是做内容拷贝。

综上两个例子，我们可以得出结论：

在非集合类对象中：对immutable对象进行copy操作，是指针拷贝，mutableCopy操作时内容拷贝；对mutable对象进行copy和mutableCopy都是内容拷贝。用代码简单表示如下：

[immutableObject copy] // 浅拷贝
[immutableObject mutableCopy] //深拷贝
[mutableObject copy] //深拷贝
[mutableObject mutableCopy] //深拷贝

2、集合类对象的copy与mutableCopy

集合类对象是指NSArray、NSDictionary、NSSet ... 之类的对象。下面先看集合类immutable对象使用copy和mutableCopy的一个例子：

NSArray *array = @[@[@"a", @"b"], @[@"c", @"d"];
NSArray *copyArray = [array copy];
NSMutableArray *mCopyArray = [array mutableCopy];

查看内容，可以看到copyArray和array的地址是一样的，而mCopyArray和array的地址是不同的。说明copy操作进行了指针拷贝，mutableCopy进行了内容拷贝。但需要强调的是：此处的内容拷贝，仅仅是拷贝array这个对象，array集合内部的元素仍然是指针拷贝。这和上面的非集合immutable对象的拷贝还是挺相似的，那么mutable对象的拷贝会不会类似呢？我们继续往下，看mutable对象拷贝的例子：

NSMutableArray *array = [NSMutableArray arrayWithObjects:[NSMutableString stringWithString:@"a"],@"b",@"c",nil];
NSArray *copyArray = [array copy];
NSMutableArray *mCopyArray = [array mutableCopy];

查看内存，如我们所料，copyArray、mCopyArray和array的内存地址都不一样，说明copyArray、mCopyArray都对array进行了内容拷贝。同样，我们可以得出结论：

在集合类对象中，对immutable对象进行copy，是指针拷贝，mutableCopy是内容拷贝；对mutable对象进行copy和mutableCopy都是内容拷贝。但是：集合对象的内容拷贝仅限于对象本身，对象元素仍然是指针拷贝。用代码简单表示如下：

[immutableObject copy] // 浅拷贝
[immutableObject mutableCopy] //单层深拷贝
[mutableObject copy] //单层深拷贝
[mutableObject mutableCopy] //单层深拷贝