深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
===============================================
对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a;
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。
#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
CExample(int b)
{ a=b;}
void Show ()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B=A;
B.Show ();
return 0;
}
运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。
|
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
26
27
|
#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
CExample(int b)
{ a = b; }
CExample(const CExample& C)
{
a = C.a;
}
void Show ()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B=A;
B.Show ();
return 0;
}
|
当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
（1）一个对象以值传递的方式传入函数体
（2）一个对象以值传递的方式从函数返回
（3）一个对象需要通过另外一个对象进行初始化。
如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。
自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。
浅拷贝和深拷贝
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
下面举个深拷贝的例子。
|
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
26
27
28
29
30
31
32
33
34
35
36
37
38
|
#include <iostream>
using namespace std;
class CA
{
public:
CA(int b,char* cstr)
{
a=b;
str=new char[b];
strcpy(str,cstr);
}
CA(const CA& C)
{
a=C.a;
str=new char[a];//深拷贝
if(str!=0)
strcpy(str,C.str);
}
void Show()
{
cout<<str<<endl;
}
~CA()
{
delete str;
}
private:
int a;
char *str;
};
int main()
{
CA A(10,"Hello!");
CA B=A;
B.Show();
return 0;
}
|
来总结一下关于 深拷贝与浅拷贝需要知道的基本概念和知识：
（1）什么时候用到拷贝函数？
b.一个对象以值传递的方式从函数返回；
如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝
（2）是否应该自定义拷贝函数？
（3）什么叫深拷贝？什么是浅拷贝？两者异同？
自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。
（4）深贝好还是浅拷贝好？
如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
============== 应用场景 ==========================
浅 复 制：在复制操作时，对于被复制的对象的每一层复制都是指针复制。
深 复 制：在复制操作时，对于被复制的对象至少有一层复制是对象复制。
完全复制：在复制操作时，对于被复制的对象的每一层复制都是对象复制。
注：1、在复制操作时，对于对象有n层是对象复制，我们可称作n级深复制，此处n应大于等于1。
2、对于完全复制如何实现（目前通用的办法是：迭代法和归档），这里后续是否添加视情况而定，
暂时不做讲解。
3、指针复制俗称指针拷贝，对象复制也俗称内容拷贝。
4、一般来讲，
浅层复制：复制引用对象的指针。
retain：始终是浅复制。引用计数每次加一。返回对象是否可变与被复制的对象保持一致。
copy：对于可变对象为深复制，引用计数不改变;对于不可变对象是浅复制， 引用计数每次加一。始终返回一个不可变对象。
mutableCopy：始终是深复制，引用计数不改变。始终返回一个可变对象。
可变对象：值发生改变，其内存首地址随之改变。
不可变对象：无论值是否改变，其内存首地址都不随之改变。
引用计数：为了让使用者清楚的知道，该对象有多少个拥有者（即有多少个指针指向同一内存地址）。
最近有一个好朋友问我，什么时候用到深浅复制呢？那么我就把我所总结的一些分享给大家，希望能帮助你们更好的理解深浅复制！
那么先让我们来看一看下边数组类型的转换
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];
通俗的讲，多个指针同时指向同一块内存区域，那么这些个指针同时拥有对该内存区的所有权。所有权的瓜分过程，这时候就要用到浅拷贝了。
则简化为：
问：什么时候用到深浅拷贝？
答：深拷贝是在要将一个对象从可变（不可变）转为不可变（可变）或者将一个对象内容克隆一份时用到；
浅拷贝是在要复制一个对象的指针时用到。
扫一扫
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
