概念

浅拷贝

浅拷贝只是对对象指针进行拷贝，与原对象指针指向同一块内存，引用计数+1.

深拷贝

深拷贝会重新申请一块内存，对象指针指向新的内存地址。与原指针存储的数据内容相同，内存地址不一样。

iOS拷贝

iOS开发中，浅拷贝和深拷贝要更复杂一些，涉及到集合对象和非集合对象的copy与mutableCopy。

• 系统非集合对象：如NSString、NSInteger、NSNumber……
• 自定义非集合对象：
• 集合对象：如NSArray、NSDictionary……

系统非集合对象的copy与mutableCopy

系统非集合对象的copy与mutableCopy,遵循以下规则：

• 可变对象的copy和mutableCopy方法都是深拷贝
• 不可变对象的copy方法是浅拷贝，mutableCopy方法是深拷贝
• copy方法返回的对象是不可变对象

示例

    //可变对象的拷贝，copy和mutableCopy都是深拷贝
    NSMutableString *str1 = [NSMutableString stringWithString:@"test"];
    NSMutableString *str2 = [str1 copy];
    //copy返回的是不可变对象，因此str2不能改变，会发生崩溃
    //[str2 appendString:@"test"];
    NSMutableString *str3 = [str1 mutableCopy];
    [str3 appendString:@"test"];
    NSLog(@"%@、 %@、 %@",str1,str2,str3);
    NSLog(@"%p、 %p、 %p",str1,str2,str3);
    
    
    NSString *str11 = @"test";
    //直接copy是浅拷贝
    NSMutableString *str12 = [str11 copy];
    //copy返回的是不可变对象，str12不能被修改，因此会发生崩溃
    //[str12 appendString:@"test"];
    //mutableCopy是深拷贝
    NSMutableString *str13 = [str11 mutableCopy];
    [str13 appendString:@"test"];
    NSLog(@"%@、 %@、 %@",str11,str12,str13);
    NSLog(@"%p、 %p、 %p",str11,str12,str13);

结果：

test、 test、 testtest
0x600001438570、 0x8abf33c3441514b6、 0x6000014385a0

test、 test、 testtest
0x107c64100、 0x107c64100、 0x6000014385d0

自定义对象的copy与mutableCopy

自定义对象需要遵循NSCopying、NSMutableCopying协议并实现- (id)copyWithZone:(NSZone *)zone、- (id)mutableCopyWithZone:(NSZone *)zone方法，否则对对象进行copy或mutableCopy会报错。

示例

#import "Test.h"
#import <objc/runtime.h>

@interface Test ()<NSCopying,NSMutableCopying>

@end


@implementation Test

- (id)copyWithZone:(NSZone *)zone {
    Test *test = [[Test alloc]init];
    return test;
}
- (id)mutableCopyWithZone:(NSZone *)zone {
    Test *test = [[Test alloc]init];
    return test;
}
- (void)encodeWithCoder:(NSCoder *)aCoder {
    unsigned int count;
    Ivar *ivar = class_copyIvarList([self class], &count);
    for (int i = 0 ; i < count ; i++) {
        Ivar iv = ivar[i];
        const char *name = ivar_getName(iv);
        NSString *strName = [NSString stringWithUTF8String:name];
        //利用KVC取值
        id value = [self valueForKey:strName];
        [aCoder encodeObject:value forKey:strName];
    }
    free(ivar);
}
- (instancetype)initWithCoder:(NSCoder *)aDecoder {
    Test *test = [[Test alloc]init];
    if (self != nil) {
        unsigned int count = 0;
        Ivar *ivar = class_copyIvarList([self class], &count);
        for (int i= 0 ;i < count ; i++) {
            Ivar var = ivar[i];
            const char *keyName = ivar_getName(var);
            NSString *key = [NSString stringWithUTF8String:keyName];
            id value = [aDecoder decodeObjectForKey:key];
            [test setValue:value forKey:key];
        }
        free(ivar);
    }
    return test;
}

- (void)dealloc {
    NSLog(@"Test-dealloc");
}

集合对象的copy与mutableCopy

实际上，集合对象与非集合对象所遵循的规则基本上是一样的。

示例

    NSMutableArray *array1 = [NSMutableArray arrayWithObjects:@"a",@"b",@"c", nil];
    NSArray *array12 = [array1 copy];
    NSMutableArray *array13 = [array1 mutableCopy];
    NSLog(@"%p、 %p、 %p",array1,array12,array13);
    NSLog(@"%p 、%p、 %p",array1[0],array12[0],array13[0]);
        
    NSMutableArray *array2 = [NSMutableArray arrayWithObjects:[NSMutableString stringWithString:@"a"],@"b",@"c", nil];
    NSArray *array22 = [array2 copy];
    NSMutableArray *array23 = [array2 mutableCopy];
    NSLog(@"%p、 %p、 %p",array2,array22,array23);
    NSLog(@"%p、 %p、 %p",array2[0],array22[0],array23[0]);
    
    
    NSArray *array3 = @[@"a",@"b",@"c"];
    NSArray *array32 = [array3 copy];
    NSMutableArray *array33 = [array3 mutableCopy];
    NSLog(@"%p、 %p、 %p",array3,array32,array33);
    NSLog(@"%p、 %p、 %p",array3[0],array32[0],array33[0]);
        
    NSArray *array4 = @[[NSMutableString stringWithString:@"a"],@"b",@"c"];
    NSArray *array42 = [array4 copy];
    NSMutableArray *array43 = [array4 mutableCopy];
    NSLog(@"%p、 %p、 %p",array4,array42,array43);
    NSLog(@"%p、 %p、 %p",array4[0],array42[0],array43[0]);

结果：

0x6000001a42d0、 0x6000001a4300、 0x6000001a4330
0x10b1bd118、 0x10b1bd118、 0x10b1bd118

0x6000001a4390、 0x6000001a4480、 0x6000001a4600
0x6000001a4360、 0x6000001a4360、 0x6000001a4360

0x10b1bd5e0、 0x10b1bd5e0、 0x6000001a81e0
0x10b1bd118、 0x10b1bd118、 0x10b1bd118

0x6000001cf000、 0x6000001cf000、 0x6000001cfcc0
0x6000001cf3f0、 0x6000001cf3f0、 0x6000001cf3f0

说明可变对象的copy和mutableCopy方法都是深拷贝；不可变对象的copy方法是浅拷贝，mutableCopy方法是深拷贝。

集合对象的完全拷贝

通过对存储的第一个数据的地址对比发现，无论是深拷贝还是浅拷贝、存储的数据是可变还是不可变，拷贝后集合中存储的数据还是同一份数据。说明上面集合对象的深拷贝并不是严格意义上的深拷贝，而是单层深拷贝（对集合对象来说，深拷贝时只是将第一层对象进行了深拷贝，内部的对象仍然是浅拷贝）。集合对象的完全拷贝，就是集合中的每一层的元素都是深拷贝。

1.使用 initWith***: copyItems:YES 方法。

自定义对象需要实现copy和mutableCopy方法。

2.先将集合进行归档，然后再解档。

自定义对象需要实现归档和接档方法。

示例

    NSMutableArray *array1 = [NSMutableArray arrayWithObjects:@"a",@"b",@"c", nil];
    NSArray *array2 = [[NSArray alloc] initWithArray:array1 copyItems:YES];
    NSLog(@"%p 、%p",array1,array2);
    NSLog(@"%p、 %p",array1[0],array2[0]);
    
    NSMutableArray *array3 = [NSMutableArray arrayWithObjects:[NSMutableString stringWithString:@"a"],@"b",@"c", nil];
    NSArray *array4 = [[NSArray alloc] initWithArray:array3 copyItems:YES];
    NSLog(@"%p、 %p",array3,array4);
    NSLog(@"%p、 %p",array3[0],array4[0]);
    
    Test *test1 = [[Test alloc] init];
    NSMutableArray *array5 = [NSMutableArray arrayWithObjects:test1, nil];
    NSArray *array6 = [[NSArray alloc] initWithArray:array5 copyItems:YES];
    NSLog(@"%p、 %p",array5,array6);
    NSLog(@"%p、 %p",array5[0],array6[0]);

结果：

0x600002769830、 0x600002768390
0x1093400b8、 0x1093400b8
0x6000027699b0、 0x600002769950
0x600002769860、 0xddb0b57a0693f81b
0x600002769a70、 0x600002b34580
0x600002b34550、 0x600002b34570

————————————————
参考文档：
iOS中的深复制与浅复制