关于浅拷贝、深拷贝的探究

浅拷贝、深拷贝、完全拷贝

在这里介绍三个概念:
浅拷贝：在拷贝操作时，对于被拷贝的对象的每一层拷贝都是指针拷贝。
深拷贝：在拷贝操作时，对于被拷贝的对象至少有一层拷贝是对象拷贝。
完全拷贝：在拷贝操作时，对于被拷贝的对象的每一层拷贝都是对象拷贝。

1.在拷贝操作时，对于对象有n层是对象拷贝，我们可称作n级深拷贝，此处n应大于等于1。
2.对于完全拷贝如何实现（目前通用的办法是：迭代法和归档），这里后续是否添加视情况而定，暂时不做讲解。
3.指针拷贝俗称指针拷贝，对象拷贝也俗称内容拷贝。
4.一般来讲，浅层拷贝，拷贝引用对象的指针;深层拷贝，拷贝引用对象内容。这种定义在多层拷贝的时候，就显得模糊。所以本文定义与它并不矛盾。反而是对它的进一步理解和说明。

深浅拷贝对比

上面说了，关于 copy，对于不可变对象是浅拷贝，引用计数每次加一。始终返回一个不可变对象; 对于可变对象为深拷贝，引用计数不改变。所以我们就按照可变和不可变来分别介绍，由于还涉及到深拷贝和完全拷贝，所以又按照容器类和非容器类分别来介绍。故分了四大类:非容器类不可变对象，容器类不可变数组，非容器类可变对象，容器类可变数组。

注: 下面整理的 demo 中str1用的是常量区的字符串，所以在引用计数时，会是无穷大。如果有兴趣可以改为堆区对象，这样引用计数会正常。其他的方面不会影响到本测试。

非容器类不可变对象

NSString *str1=[NSString stringWithFormat:@"我屮艸芔茻"];
//    NSString *str1=@"one day";printf("\n初始化引用计数为：%lu",str1.retainCount);
NSString *strCopy1=[str1 retain];
printf("\nretain引用计数为：%lu",str1.retainCount);
NSString *strCopy2=[str1 copy];
printf("\ncopy后引用计数为：%lu",str1.retainCount);
NSString *strCopy3=[str1 mutableCopy];
printf("\n继续mutableCopy后为：%lu\n",str1.retainCount);printf("\n非容器类不可变对象");
printf("\n原始地址：%p",str1);
printf("\nretain拷贝：%p",strCopy1);
printf("\ncopy拷贝：%p",strCopy2);
printf("\nmutableCopy拷贝：%p",strCopy3);

打印结果:

初始化引用计数为：1
retain引用计数为：2
copy后引用计数为：3
继续mutableCopy后为：3
非容器类不可变对象
原始地址：_0x60400025c260
retain拷贝：0x60400025c260
copy拷贝：0x60400025c260
mutableCopy拷贝：0x600000059c20

容器类不可变对象

NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];printf("\n初始化引用计数为：%lu",array1.retainCount);
NSArray *arrayCopy1 = [array1 retain];
printf("\nretain后引用计数为：%lu",array1.retainCount);
NSArray *arrayCopy2 = [array1 copy];
printf("\ncopy后引用计数为：%lu",array1.retainCount);
NSArray *arrayCopy3 = [array1 mutableCopy];
printf("\nmutableCopy后引用计数为：%lu\n",array1.retainCount);printf("\n容器类不可变数组");
printf("\n原始地址：%p\t%p",array1,[array1 objectAtIndex:1]);
printf("\nretain拷贝：%p\t%p",arrayCopy1,[arrayCopy1 objectAtIndex:1]);
printf("\ncopy拷贝：%p\t%p",arrayCopy2,[arrayCopy2 objectAtIndex:1]);
printf("\nmutableCopy拷贝：%p\t%p",arrayCopy3,[arrayCopy3 objectAtIndex:1]);

打印结果:

初始化引用计数为：1
retain后引用计数为：2
copy后引用计数为：3
mutableCopy后引用计数为：3
容器类不可变数组
原始地址：0x600000444050 0x10fef20b0
retain拷贝：0x600000444050 0x10fef20b0
copy拷贝：0x600000444050 0x10fef20b0
mutableCopy拷贝：0x600000444170 0x10fef20b0

非容器类可变对象

NSMutableString *str2=[NSMutableString stringWithString:@"two day"];printf("\n初始化引用计数为：%lu",str2.retainCount);
NSMutableString *strCpy1=[str2 retain];
printf("\nretain后引用计数为：%lu",str2.retainCount);
NSMutableString *strCpy2=[str2 copy];
printf("\ncopy后引用计数为：%lu",str2.retainCount);
NSMutableString *strCpy3=[str2 mutableCopy];
printf("\nmutableCopy后引用计数为：%lu\n",str2.retainCount);printf("\n非容器类可变对象");
printf("\n原始地址：%p",str2);
printf("\nretin拷贝：%p",strCpy1);
printf("\ncopy拷贝：%p",strCpy2);
printf("\nmutableCopy拷贝：%p",strCpy3);

打印结果:

初始化引用计数为：1
retain后引用计数为：2
copy后引用计数为：2
mutableCopy后引用计数为：2
非容器类可变对象
原始地址：0x6000004441a0
retin拷贝：_0x6000004441a0
copy拷贝：0xa796164206f77747
mutableCopy拷贝：0x600000444140

容器类可变对象

NSMutableArray *array2   = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];printf("\n初始化引用计数为：%lu",array2.retainCount);
NSMutableArray *arrayCpy1 = [array2 retain];
printf("\nretain后引用计数为：%lu",array2.retainCount);
NSMutableArray *arrayCpy2=[array2 copy];
printf("\ncopy后引用计数为：%lu",array2.retainCount);
NSMutableArray *arrayCpy3 = [array2 mutableCopy];
printf("\nmutableCopy后引用计数为：%lu\n",array2.retainCount);printf("\n容器类可变数组");
printf("\n原始地址：：%p\t%p",array2,[array2 objectAtIndex:1]);
printf("\nretain拷贝：%p\t%p",arrayCpy1,[arrayCpy1 objectAtIndex:1]);
printf("\ncopy拷贝：%p\t%p",arrayCpy2,[arrayCpy2 objectAtIndex:1]);
printf("\nnmutableCopy拷贝：%p\t%p",arrayCpy3,[arrayCpy3 objectAtIndex:1]);

打印结果:

初始化引用计数为：1
retain后引用计数为：2
copy后引用计数为：2
mutableCopy后引用计数为：2
容器类可变数组
原始地址：：0x60400025c2f0 0x10fef2150
retain拷贝：_0x60400025c2f0 0x10fef2150
copy拷贝：_0x60400025c080 0x10fef2150
nmutableCopy拷贝：0x60400025bf90 0x10fef2150

应用

1、不可变对象→可变对象的转换：

NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray  *str2=[array1 mutableCopy];

2、可变对象→不可变对象的转换：

NSMutableArray *array2 = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];
NSArray *array1 = [array2 Copy];

3、可变对象→可变对象的转换（不同指针变量指向不同的内存地址）：

NSMutableArray *array1 = [NSMutableArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray *str2 = [array1 mutableCopy];

通过上边的两个例子，我们可轻松的将一个对象在可变和不可变之间转换，并且这里不用考虑内存使用原则（即引用计数的问题）。没错，这就是深拷贝的魅力了。

4、同类型对象之间的指针拷贝（不同指针变量指向同一块内存地址）：

  //a、NSMutableString *str1 = [NSMutableString stringWithString:@"two day"];NSMutableString *str2 = [str1 retain];[str1  release];//b、NSArray *array1 = [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];NSArray *str2 = [array1 Copy];[array1 release];

应用总结:
1.深拷贝是在要将一个对象从可变（不可变）转为不可变（可变）或者将一个对象内容克隆一份时用到;
2.浅拷贝是在要拷贝一个对象的指针时用到。
3.深拷贝赋值过程：输入数据→寄存器处理→开辟内存→写入数据。
一次深拷贝，可以得到被拷贝对象指针，并进行一次赋值操作。

对于深拷贝和完全拷贝, 下篇文章深拷贝和完全拷贝对比的探究会具体谈一谈.