最近一直被问到深浅拷贝的问题。自己也确实不太清楚怎么回事，现在来研究一下。

什么是深浅拷贝

• 浅拷贝：指针拷贝，不会产生新对象
• 深拷贝：内容拷贝，会产生新对象

iOS提供了copy和mutableCopy方法，顾名思义，copy就是复制一个immutable对象，而mutableCopy复制了一个mutable对象。但是具体他们各自是深拷贝还是浅拷贝呢？下边来分析一下。

一、系统的非容器类对象：NSString、NSNumber等

1、不可变字符串

    NSString *string = @"xxx";
    
    NSString *stringCopy = [string copy];
    
    NSMutableString * stringMutableCopy = [string mutableCopy];
    
    [stringMutableCopy appendString:@"123"];
    
    NSLog(@"1 : %@ %p",string,string);
    
    NSLog(@"2 : %@ %p",stringCopy,stringCopy);
    
    NSLog(@"3 : %@ %p",stringMutableCopy,stringMutableCopy);
    

输出结果

从输出结果可以看出，string和stringCopy指向同一块内存区域，进行了指针拷贝。而stringMutableCopy则和String的地址不一样，进行了内容拷贝。

2、可变字符串

    NSMutableString *string = [NSMutableString stringWithString:@"xxx"];

    NSString *stringCopy = [string copy];
    
    NSMutableString *mStringCopy = [string copy];
    
    NSMutableString *stringMCopy = [string mutableCopy];
    
//    [mStringCopy appendString:@"mmm"];
    
    [string appendString:@"yyy"];
    
    [stringMCopy appendString:@"!!!"];
    
    NSLog(@"1 : %@ %p",string,string);
    
    NSLog(@"2 : %@ %p",stringCopy,stringCopy);
    
    NSLog(@"3 : %@ %p",mStringCopy,mStringCopy);

    NSLog(@"4 : %@ %p",stringMCopy,stringMCopy);

输出结果

从输出结果可以看出，四个地址均不相同，也就意味着产生了新的对象，所以当可变字符串不管调用copy还是mutableCopy都是深拷贝。

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

在非集合类对象中：对immutable对象进行copy操作，是指针复制，mutableCopy操作时内容复制；对mutable对象进行copy和mutableCopy都是内容复制。

• [immutableObject copy] // 浅复制
• [immutableObject mutableCopy] //深复制
• [mutableObject copy] //深复制
• [mutableObject mutableCopy] //深复制

二、系统的容器类对象：指NSArray，NSDictionary等。对于容器类本身，上面讨论的结论也是适用的，需要探讨的是复制后容器内对象的变化。

1、不可变数组

//copy返回不可变对象，mutablecopy返回可变对象
    NSArray *array1 = [NSArray arrayWithObjects:@"a",@"b",@"c", nil];
    
    NSArray *arrayCopy1 = [array1 copy];
    
    NSLog(@"1 : %@  %p ",array1,array1);
    
    NSLog(@"2 : %@  %p ",arrayCopy1,arrayCopy1);
    //mArrayCopy1是array1的可变副本，指向的对象和array1不同，但是其中的元素和array1中的元素指向的是同一个对象。mArrayCopy1还可以修改自己的对象

    NSMutableArray *marray1 = [array1 mutableCopy];
    
    NSLog(@"3 : %@  %p ",marray1,marray1);

    [marray1 addObject:@"1"];
    NSLog(@"4 : %@  %p ",marray1,marray1);

    [marray1 removeObjectAtIndex:1];
    NSLog(@"5 : %@  %p ",marray1,marray1);

输出结果

从结果来看，当不可变数组调用copy的时候，指针地址没有发生改变，意味着没有产生新的对象，所以属于浅拷贝；
当不可变数组调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。

2、可变数组

 NSMutableArray *mArray = [NSMutableArray arrayWithObjects:@"a", @"b", @"c", nil];
    
    NSArray *arrayCopy1 = [mArray copy];
    
    NSMutableArray *arrayCopy2 = [mArray copy];
    
    NSMutableArray *arrayCopy3 = [mArray mutableCopy];
    
    [mArray addObject:@"d"];
    
    [arrayCopy3 addObject:@"e"];
    
    NSLog(@"1 : %@ %p",mArray,mArray);
    
    NSLog(@"2 : %@ %p",arrayCopy1,arrayCopy1);
    
    NSLog(@"3 : %@ %p",arrayCopy2,arrayCopy2);
    
    NSLog(@"4 : %@ %p",arrayCopy3,arrayCopy3);

输出结果

从输出结果来看，四个地址均不相同，也就意味着产生了新的对象，所以当可变数组不管调用copy还是mutableCopy都是深拷贝。

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

在集合类对象中，对immutable对象进行copy，是指针复制，mutableCopy是内容复制；对mutable对象进行copy和mutableCopy都是内容复制。

• [immutableObject copy] // 浅复制
• [immutableObject mutableCopy] //深复制
• [mutableObject copy] //深复制
• [mutableObject mutableCopy] //深复制

但是需要注意的是：容器内元素都是指针复制。

见下面例子

    NSArray *dataArray = @[[NSMutableString stringWithFormat:@"123"],@"22",@"333"];
    
    NSArray *data1 = [dataArray copy];
    
    NSArray *data2 = [dataArray mutableCopy];
    
    NSMutableString *mus = dataArray[0];
    
    [mus appendString:@"xxx"];
    
    NSString *ss = dataArray[1];
    ss = @"xccc";
    
    NSLog(@"1 : %@ %p",dataArray,dataArray);
    
    NSLog(@"2 : %@ %p",data1,data1);

    NSLog(@"3 : %@ %p",data2,data2);

输出结果

由此可见，对于容器而言，其元素对象始终是指针复制。如果需要元素对象也是对象复制，就需要实现深拷贝。所以针对上述结论要做一些修改。

在集合类对象中，对immutable对象进行copy，是指针复制，mutableCopy是内容复制；对mutable对象进行copy和mutableCopy都是内容复制。但是：集合对象的内容复制仅限于对象本身，对象元素仍然是指针复制。

• [immutableObject copy] // 浅复制
• [immutableObject mutableCopy] //单层深复制
• [mutableObject copy] //单层深复制
• [mutableObject mutableCopy] //单层深复制

集合类的深复制(deep copy)

集合的深复制有两种方法。可以用 initWithArray:copyItems: 将第二个参数设置为YES即可深复制，如

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

如果你用这种方法深复制，集合里的每个对象都会收到 copyWithZone: 消息。如果集合里的对象遵循 NSCopying 协议，那么对象就会被深复制到新的集合。如果对象没有遵循 NSCopying 协议，而尝试用这种方法进行深复制，会在运行时出错。copyWithZone: 这种拷贝方式只能够提供一层内存拷贝(one-level-deep copy)，而非真正的深复制。

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

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

集合的单层深复制 (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...

从文中可以看出，苹果认为这种复制不是真正的深复制，而是将其称为单层深复制(one-level-deep copy)。因此，网上有人对浅复制、深复制、单层深复制做了概念区分。

• 浅复制(shallow copy)：在浅复制操作时，对于被复制对象的每一层都是指针复制。
• 深复制(one-level-deep copy)：在深复制操作时，对于被复制对象，至少有一层是深复制。
• 完全复制(real-deep copy)：在完全复制操作时，对于被复制对象的每一层都是对象复制。

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

三、自定义对象的拷贝

@interface Person : NSObject <NSCopying>

@property (nonatomic, copy) NSString *name;

@property (nonatomic, assign) NSInteger age;

@end


@implementation Person

- (id)copyWithZone:(NSZone *)zone {

    Person *p = [[Person allocWithZone:zone]init];

    p.name = self.name;
    
    p.age = self.age;
    
    return p;

}

   Person *p = [[Person alloc]init];
    
    p.name = @"vayne";
    
    p.age = 24;
    
    Person *p1 = [p copy];
    
    p1.name = @"jax";
    
    NSLog(@"p : %@ %@",p,p.name);
    
    NSLog(@"p1 : %@ %@",p1,p1.name);

输出结果

当自定义对象调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝

总结：当不可变类型对象调用copy，不会产生新的对象，属于浅拷贝，但是用mutableCopy会产生新的对象，属于深拷贝；其他类型对象不管调用copy还是mutableCopy，都会产生新的对象，属于深拷贝。