OBJECT-C 深拷贝和浅拷贝

类型转换

第一种:非容器类不可变对象

第二种:容器类不可变对象

第三种:非容器类可变对象

第四种:容器类可变对象

概念

浅 复 制:对于被复制的对象的每一层复制都是指针复制(复制对象的指针)。

深 复 制:在复制操作时,对于被复制的对象至少有一层复制是对象复制(复制引用对象内容)。

完全复制:在复制操作时,对于被复制的对象的每一层复制都是对象复制。

  1. 在复制操作时,对于对象有n层是对象复制,我们可称作n级深复制,此处n应大于等于1。

  2. 对于完全复制如何实现(目前通用的办法是:迭代法和归档),这里后续是否添加视情况而定,暂时不做讲解。

  3. 指针复制俗称指针拷贝,对象复制也俗称内容拷贝。

retain

始终是浅复制。引用计数每次加一。返回对象是否可变与被复制的对象保持一致。

copy

对于可变对象为深复制,引用计数不改变;

对于不可变对象是浅复制,引用计数每次加一。

始终返回一个不可变对象。

mutableCopy

始终是深复制,引用计数不改变。始终返回一个可变对象。

不可变对象:值发生改变,其内存首地址随之改变。

可变对象:无论值是否改变,其内存首地址都不随之改变。

引用计数:为了让使用者清楚的知道,该对象有多少个拥有者(即有多少个指针指向同一内存地址)。

  1. 不可变对象→可变对象的转换:
1
2
NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray *str2=[array1 mutableCopy];
  1. 可变对象→不可变对象的转换:
1
2
NSMutableArray *array2 = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];
NSArray *array1=[ array2 Copy];
  1. 可变对象→可变对象的转换(不同指针变量指向不同的内存地址):
1
2
NSMutableArray *array1= [NSMutableArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray *str2=[array1 mutableCopy];

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

  1. 同类型对象之间的指针复制(不同指针变量指向同一块内存地址):

a

1
2
3
NSMutableString *str1=[NSMutableString stringWithString:@"two day"];
NSMutableString *str2=[str1 retain];
[str1 release];

b

1
2
3
NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSArray *str2=[array1 Copy];
[array1 release];

通俗的讲,多个指针同时指向同一块内存区域,那么这些个指针同时拥有对该内存区的所有权。所有权的瓜分过程,这时候就要用到浅拷贝了。

则简化为:

问:什么时候用到深浅拷贝?

答:深拷贝是在要将一个对象从可变(不可变)转为不可变(可变)或者将一个对象内容克隆一份时用到;浅拷贝是在要复制一个对象的指针时用到。

#测试以下代码时需将Project中的Ojective-C automic Reference couting设置为NO(Apple LLVM 5.0-language -Modules)

第一种:非容器类不可变对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
NSString *str1=@"one day";
printf("初始化赋值引用计数为::::%lu",str1.retainCount);
NSString *strCopy1=[str1 retain];
printf("\n继续retain引用计数为:::%lu",str1.retainCount);
NSString *strCopy2=[str1 copy];
printf("\n继续copy后引用计数为::::%lu",str1.retainCount);
NSString *strCopy3=[str1 mutableCopy];
printf("\n继续mutableCopy后为:::%lu\n",str1.retainCount);
printf("\n非容器类不可变对象\n原始地址::::::::::%p",str1);
printf("\nretain复制::::::::%p",strCopy1);
printf("\ncopy复制::::::::::%p",strCopy2);
printf("\nmutableCopy复制:::%p\n",strCopy3);
// 初始化赋值引用计数为:18446744073709551615
// 继续retain引用计数为:18446744073709551615
// 继续copy后引用计数为:18446744073709551615
// 继续mutableCopy后为:18446744073709551615
//原始地址::::::::::0x1000033d0
//retain复制::::::::0x1000033d0//浅复制
//copy复制::::::::::0x1000033d0//浅复制
//mutableCopy复制:::0x10010c420//深复制

小提示:这里很多人都说是赋值,所以就好解释这里没引用计数的概念。而且也能解释为什么

1
2
3
NSString *strCopy2=[str1 copy];
NSMutableString *strCopy2=[str1 copy];

这样都不会报错的原因了。那既然只是简单赋值为什么要这么麻烦呢,直接

1
2
3
NSString *strCopy2=*str1;
NSMutableString *strCopy2=*str1;

其实大家都看出来了,这里是指针变量,只存在“指针的复制”,

跟赋值概念完全不同,虽然这里看起来很像。

原来该类型是字符串常量时,系统会为我们优化,声明了多个字符串,但是都是常量,且内容相等,那么系统就只为我们申请一块空间。

疑问: 深复制=浅复制+赋值吗?

赋值过程:输入数据→寄存器处理→开辟内存→写入数据。

一次深复制,可以得到被复制对象指针,并进行一次赋值操作。

第二种:容器类不可变对象

  1. 不可变对象→可变对象的转换:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
printf("\n初始化赋值引用计数为::::::::::::%lu",[array1 retainCount]);
NSArray *arrayCopy1 = [array1 retain];
printf("\n继续retain后引用计数为:::::::::%lu",array1.retainCount);
NSArray *arrayCopy2 = [array1 copy];
printf("\n继续copy后引用计数为:::::::::::%lu",array1.retainCount);
NSArray *arrayCopy3 = [array1 mutableCopy];
printf("\n继续mutableCopy后引用计数为::::%lu\n",array1.retainCount);
printf("\n容器类不可变数组\n原始地址::::::::::%p\t\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
//容器类不可变数组
//原始地址::::::::::0x10010c6b0 0x100003410
//retain复制::::::::0x10010c6b0 0x100003410//浅复制
//copy复制::::::::::0x10010c6b0 0x100003410//浅复制
//mutableCopy复制:::0x10010c760 0x100003410//深复制

第三种:非容器类可变对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
NSMutableString *str2=[NSMutableString stringWithString:@"two day"];
printf("\n初始化赋值引用计数为::::::::::::%lu",str2.retainCount);
NSMutableString *strCpy1=[str2 retain];
printf("\n继续retain后引用计数为:::::::::%lu",str2.retainCount);
NSMutableString *strCpy2=[str2 copy];
printf("\n继续copy后引用计数为:::::::::::%lu",str2.retainCount);
NSMutableString *strCpy3=[str2 mutableCopy];
printf("\n继续mutableCopy后引用计数为::::%lu\n",str2.retainCount);
printf("\n非容器类可变对象\n原始地址::::::::::%p",str2);
printf("\nretin复制::::::::%p",strCpy1);
printf("\ncopy复制::::::::::%p",strCpy2);
printf("\nmutableCopy复制:::%p",strCpy3);
//结果
//初始化赋值引用计数为::::::::::::1
//继续retain后引用计数为:::::::::2
//继续copy后引用计数为:::::::::::2
//继续mutableCopy后引用计数为::::2
//非容器类可变对象
//原始地址::::::::::0x10010c560
//retain复制::::::::0x10010c560//浅复制
//copy复制::::::::::0x100102720//深复制
//mutableCopy复制:::0x10010c880//深复制

第四种:容器类可变对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
NSMutableArray *array2 = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];
printf("\n初始化赋值引用计数为::::::::::%lu",array2.retainCount);
NSMutableArray *arrayCpy1 = [array2 retain];
printf("\n继续retain后引用计数为:::::::%lu",array2.retainCount);
NSMutableArray *arrayCpy2=[array2 copy];
printf("\n继续copy后引用计数为:::::::::%lu",array2.retainCount);
NSMutableArray *arrayCpy3 = [array2 mutableCopy];
printf("\n继续mutableCopy后引用计数为::%lu\n",array2.retainCount);
printf("\n容器类可变数组\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
//容器类可变数组
//原始地址:::::::::::0x10010e6c0 0x1000034b0
//retain复制:::::::::0x10010e6c0 0x1000034b0//浅复制
//copy复制:::::::::::0x10010e790 0x1000034b0//深复制
//nmutableCopy复制:::0x10010e7c0 0x1000034b0//深复制