深拷贝和浅拷贝有什么区别？
https://stackoverflow.com/questions/184710
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
深拷贝和浅拷贝有什么区别？
解决方案
浅拷贝尽可能少复制。集合的浅表副本是集合结构的副本，而不是元素。使用浅拷贝，两个集合现在共享各个元素。
深拷贝复制一切。集合的深层副本是两个集合，原始集合中的所有元素都是重复的。
其他提示
广度与深度;根据您的对象作为根节点的引用树来思考。
浅：
![](“https://upload.wikimedia.org/wikipedia/en/thumb/6/6c/Pre_shallow_deep_copy.svg/120px-Pre_shallow_deep_copy.svg.png"alt)
变量A和B指的是不同的存储区域，当B被分配给A时，两个变量指的是相同的存储区域。以后对其中任何内容的修改会立即反映在其他内容中，因为它们共享内容。
深：
![](“https://upload.wikimedia.org/wikipedia/commons/thumb/5/5f/Deep_copy_in_progress.svg/120px-Deep_copy_in_progress.svg.png"alt)
![](“https://upload.wikimedia.org/wikipedia/en/thumb/0/00/Deep_copy_done.svg/120px-Deep_copy_done.svg.png"alt)
变量A和B指的是不同的存储区，当B被分配给A时，A指向的存储区中的值被复制到B指向的存储区中。后来对其中任何内容的修改仍然是A或B的唯一内容;内容不共享。
简而言之，这取决于什么指向什么。在浅拷贝中，对象B指向对象A在内存中的位置。在深层复制中，对象A的内存位置中的所有内容都会被复制到对象B的内存位置。
这篇wiki文章有一个很棒的图表。
特别是对于iOS开发者：
如果 B 是 A 的浅拷贝，那么对于原始数据，它就像 B = [A assign]; 和对象，它就像 B = [A retain] ;
B和A指向相同的内存位置
如果 B 是 A 的深层拷贝，那么它就像 B = [A copy];
B和A指向不同的内存位置
B内存地址与A的
相同B与A的
具有相同的内容
浅拷贝：＆nbsp;将成员值从一个对象复制到另一个对象。
深层复制：＆nbsp;＆nbsp;＆nbsp;＆nbsp;将成员值从一个对象复制到另一个对象。
＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;＆nbsp;任何指针对象都是重复的并且深度复制
示例：
class String
{
int size;
char* data;
};
String s1("Ace"); // s1.size = 3 s1.data=0x0000F000
String s2 = shallowCopy(s1);
// s2.size =3 s2.data = 0X0000F000
String s3 = deepCopy(s1);
// s3.size =3 s3.data = 0x0000F00F
// (With Ace copied to this location.)
我在这里没有看到简短易懂的答案 - 所以我会试一试。
使用浅拷贝时，源指向的任何对象也会被目标指向（因此不会复制引用的对象）。
使用深层复制时，将复制源指向的任何对象，并且目标指向该副本（因此现在每个引用的对象将有2个）。这会递归对象树。
{想象一下两个对象：相同类型_t的A和B（关于C ++）你正在考虑浅/深复制A到B}
浅拷贝： 只需将A的引用副本复制到B.将其视为A地址的副本。 因此，A和B的地址是相同的，即它们将指向相同的存储位置，即数据内容。
深层复制 只需复制A的所有成员，在B的不同位置分配内存，然后将复制的成员分配给B以实现深层复制。这样，如果A变为不存在，则B在存储器中仍然有效。正确使用的术语是克隆，您知道它们两者完全相同但却不同（即存储为存储空间中的两个不同实体）。您还可以提供克隆包装器，您可以通过包含/排除列表决定在深层复制期间选择哪些属性。这是创建API时非常常见的做法。
您可以选择执行浅拷贝 ONLY_IF ，了解所涉及的赌注。如果你有大量的指针需要在C ++或C中处理，那么对象的浅层副本真的是一个坏主意。
EXAMPLE_OF_DEEP COPY _ 例如，当您尝试进行图像处理和对象识别时，需要屏蔽“不相关且重复的动作”。离开你的加工区域。如果您正在使用图像指针，那么您可能具有保存这些蒙版图像的规范。现在......如果您执行图像的浅层复制，当指针引用从堆栈中被杀死时，您丢失了引用及其副本，即在某些时候存在访问冲突的运行时错误。在这种情况下，您需要的是克隆它的图像的深层副本。通过这种方式，您可以在将来需要时检索蒙版。
EXAMPLE_OF_SHALLOW_COPY 与StackOverflow中的用户相比，我不是很了解，所以请随意删除此部分并提供一个很好的示例，如果您可以澄清一下。但是我真的认为如果你知道你的程序将会运行一段无限的时间，即连续的“推 - 弹”，那么做浅拷贝不是一个好主意。使用函数调用在堆栈上操作。如果你向业余或新手演示某些东西（例如C / C ++教程），那么它可能没问题。但是如果你正在运行一个应用程序，如监视和检测系统，或声纳跟踪系统，你不应该对你的物体进行浅层复制，因为它迟早会杀死你的程序。
char * Source = "Hello, world.";
char * ShallowCopy = Source;
char * DeepCopy = new char(strlen(Source)+1);
strcpy(DeepCopy,Source);
'ShallowCopy'指向内存中与'Source'相同的位置。 “DeepCopy”指向内存中的不同位置，但内容相同。
什么是浅拷贝？
浅拷贝是对象的逐位拷贝。创建一个新对象，该对象具有原始对象中值的精确副本。如果对象的任何字段是对其他对象的引用，则仅复制引用地址，即仅复制存储器地址。 
在此图中， MainObject1 具有int类型的字段 field1 ，以及 ContainObject 类型的 ContainObject1 。当您执行 MainObject1 的浅层副本时， MainObject2 是使用 field2 创建的，其中包含 field1 的复制值且仍然指向 ContainObject1 本身。请注意，由于 field1 是基本类型，因此将其值复制到 field2 ，但由于 ContainedObject1 是一个对象， MainObject2 仍然指向 ContainObject1 。因此，对 MainObject1 中的 ContainObject1 所做的任何更改都将反映在 MainObject2 中。
现在如果这是浅拷贝，让我们看看什么是深拷贝？
什么是深层复制？
深拷贝会复制所有字段，并复制字段指向的动态分配的内存。将对象与其引用的对象一起复制时，会发生深层复制。
在此图中，MainObject1的字段为 field1 ，类型为int， ContainObject1 的类型为 ContainObject 。当您执行 MainObject1 的深层复制时， MainObject2 是使用 field2 创建的，其中包含 field1 和<的复制值代码> ContainObject2 ，包含 ContainObject1 的复制值。请注意，对 MainObject1 中的 ContainObject1 所做的任何更改都不会反映在 MainObject2 中。
在面向对象编程中，类型包括成员字段的集合。这些字段可以通过值或通过引用（即，指向值的指针）存储。
在浅层副本中，将创建该类型的新实例，并将值复制到新实例中。参考指针也像值一样被复制。因此，引用指向原始对象。对引用存储的成员所做的任何更改都会同时显示在原始对象和副本中，因为没有对引用的对象进行复制。
在深层复制中，按值存储的字段将像以前一样复制，但不会复制通过引用存储的对象的指针。相反，深度复制由引用的对象组成，并存储指向新对象的指针。对这些引用对象所做的任何更改都不会影响该对象的其他副本。
'ShallowCopy'指向内存中与'Source'相同的位置。 “DeepCopy”指向内存中的不同位置，但内容相同。
var source = { firstName="Jane", lastname="Jones" };
var shallow = ShallowCopyOf(source);
var deep = DeepCopyOf(source);
source.lastName = "Smith";
WriteLine(source.lastName); // prints Smith
WriteLine(shallow.lastName); // prints Smith
WriteLine(deep.lastName); // prints Jones
浅克隆：
定义：“对象的浅表副本复制＆＃8216;主要＆＃8217;对象，但不复制内部对象。“
当自定义对象（例如Employee）只有原始的String类型变量时，则使用Shallow Cloning。
Employee e = new Employee(2, "john cena");
Employee e2=e.clone();
在重写的clone（）方法中返回 super.clone（）; ，你的工作结束了。
深度克隆：
定义：“与浅拷贝不同，深拷贝是对象的完全独立的副本。”
表示Employee对象拥有另一个自定义对象时：
Employee e = new Employee(2, "john cena", new Address(12, "West Newbury", "Massachusetts");
然后你必须编写代码来克隆'Address'对象以及重写的clone（）方法。否则，Address对象将不会克隆，当您更改克隆的Employee对象中的Address值时，它会导致错误，这也反映了原始对象。
深层复制
深拷贝会复制所有字段，并复制字段指向的动态分配的内存。将对象与其引用的对象一起复制时，会发生深层复制。
浅拷贝
浅拷贝是对象的逐位拷贝。创建一个新对象，该对象具有原始对象中值的精确副本。如果对象的任何字段是对其他对象的引用，则仅复制引用地址，即仅复制存储器地址。
浅拷贝 - 原始和浅层复制对象中的引用变量引用 common 对象。
深层复制 - 原始和深层复制对象中的引用变量引用了不同的对象。
clone总是做浅拷贝。
public class Language implements Cloneable{
String name;
public Language(String name){
this.name=name;
}
public String getName() {
return name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
主要课程如下 -
public static void main(String args[]) throws ClassNotFoundException, CloneNotSupportedException{
ArrayList<Language> list=new ArrayList<Language>();
list.add(new Language("C"));
list.add(new Language("JAVA"));
ArrayList<Language> shallow=(ArrayList<Language>) list.clone();
//We used here clone since this always shallow copied.
System.out.println(list==shallow);
for(int i=0;i<list.size();i++)
System.out.println(list.get(i)==shallow.get(i));//true
ArrayList<Language> deep=new ArrayList<Language>();
for(Language language:list){
deep.add((Language) language.clone());
}
System.out.println(list==deep);
for(int i=0;i<list.size();i++)
System.out.println(list.get(i)==deep.get(i));//false
}
上面的OutPut将是 -
false true true
false false false
对原始对象所做的任何更改都将反映在浅层对象中而不是深层对象中。
list.get(0).name="ViSuaLBaSiC";
System.out.println(shallow.get(0).getName()+" "+deep.get(0).getName());
OutPut - ViSuaLBaSiC C
我想举例而非正式定义。
var originalObject = {
a : 1,
b : 2,
c : 3,
};
此代码显示浅层副本：
var copyObject1 = originalObject;
console.log(copyObject1.a); // it will print 1
console.log(originalObject.a); // it will also print 1
copyObject1.a = 4;
console.log(copyObject1.a); //now it will print 4
console.log(originalObject.a); // now it will also print 4
var copyObject2 = Object.assign({}, originalObject);
console.log(copyObject2.a); // it will print 1
console.log(originalObject.a); // it will also print 1
copyObject2.a = 4;
console.log(copyObject2.a); // now it will print 4
console.log(originalObject.a); // now it will print 1
此代码显示深层副本：
var copyObject2 = Object.assign({}, originalObject);
console.log(copyObject2.a); // it will print 1
console.log(originalObject.a); // it will also print 1
copyObject2.a = 4;
console.log(copyObject2.a); // now it will print 4
console.log(originalObject.a); // !! now it will print 1 !!
struct sample
{
char * ptr;
}
void shallowcpy(sample & dest, sample & src)
{
dest.ptr=src.ptr;
}
void deepcpy(sample & dest, sample & src)
{
dest.ptr=malloc(strlen(src.ptr)+1);
memcpy(dest.ptr,src.ptr);
}
简单来说，浅拷贝类似于按引用呼叫，深拷贝类似于按值呼叫
在Call By Reference中，函数的形式参数和实际参数都指的是相同的内存位置和值。
在Call By Value中，函数的形式参数和实际参数都指的是不同的内存位置，但具有相同的值。
想象一下，有两个名为arr1和arr2的数组。
arr1 = arr2; //shallow copy
arr1 = arr2.clone(); //deep copy
浅复制正在创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果字段是值类型 - ＆gt;执行该字段的逐位复制;对于引用类型 - ＆gt;复制引用但引用的对象不是;因此原始对象及其克隆引用相同的对象。
深副本正在创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果字段是值类型 - ＆gt;执行该字段的逐位复制。如果字段是引用类型 - >执行引用对象的新副本。要克隆的类必须标记为[Serializable]。
摘自[博客]： http：// sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html
深层复制涉及使用一个对象的内容来创建同一个类的另一个实例。在深层副本中，两个对象可能包含相同的信息，但目标对象将拥有自己的缓冲区和资源。任何一个对象的破坏都不会影响剩余的对象。重载的赋值运算符将创建对象的深层副本。
浅拷贝涉及将一个对象的内容复制到同一个类的另一个实例中，从而创建镜像。由于直接复制了引用和指针，这两个对象将共享另一个对象的外部包含的内容，这是不可预测的。
<强>解释
使用复制构造函数，我们只需按成员复制数据值成员。这种复制方法称为浅拷贝。如果对象是一个简单的类，由内置类型和没有指针组成，这是可以接受的。此函数将使用值和对象，并且不会使用浅复制更改其行为，仅复制作为成员的指针的地址，而不复制地址指向的值。然后，该功能会无意中改变对象的数据值。当函数超出范围时，带有所有数据的对象副本将从堆栈中弹出。
如果对象有任何指针，则需要执行深层复制。使用对象的深层副本，在free store中为对象分配内存，并复制指向的元素。深度副本用于从函数返回的对象。
要为其他答案添加更多内容，
- 对象的浅副本可以根据值的属性执行副本，并根据参考类型的属性复制。
- 对象的深层副本执行基于价值类型的属性的值，以及基于参考类型的属性的副本（参考类型）深处的参考类型属性
浅复制构造一个新的复合对象，并将其引用插入到原始对象中。
与浅层复制不同，deepcopy构造新的复合对象，并且还插入原始复合对象的原始对象的副本。
让我们举个例子。
import copy
x =[1,[2]]
y=copy.copy(x)
z= copy.deepcopy(x)
print(y is z)
上面的代码打印为FALSE。
让我们看看如何。
原始复合对象 x = [1，[2]] （称为复合，因为它在对象内部有对象（Inception））
如图所示，列表中有一个列表。
然后我们使用 y = copy.copy（x）创建它的浅表副本。 python在这里做的是，它将创建一个新的复合对象，但它们内部的对象指向orignal对象。
在图像中，它为外部列表创建了一个新副本。但内部列表与原始列表保持一致。
现在我们使用 z = copy.deepcopy（x）创建它的深度复制。 python在这里做的是，它将为外部列表和内部列表创建新对象。如下图所示（红色突出显示）。
最后代码打印 False ，因为y和z不是同一个对象。
HTH。
浅拷贝不会创建新的引用，但深拷贝将创建新的引用。
这是解释深层和浅层副本的程序。
public class DeepAndShollowCopy {
int id;
String name;
List<String> testlist = new ArrayList<>();
/*
// To performing Shallow Copy
// Note: Here we are not creating any references.
public DeepAndShollowCopy(int id, String name, List<String>testlist)
{
System.out.println("Shallow Copy for Object initialization");
this.id = id;
this.name = name;
this.testlist = testlist;
}
*/
// To performing Deep Copy
// Note: Here we are creating one references( Al arraylist object ).
public DeepAndShollowCopy(int id, String name, List<String> testlist) {
System.out.println("Deep Copy for Object initialization");
this.id = id;
this.name = name;
String item;
List<String> Al = new ArrayList<>();
Iterator<String> itr = testlist.iterator();
while (itr.hasNext()) {
item = itr.next();
Al.add(item);
}
this.testlist = Al;
}
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Oracle");
list.add("C++");
DeepAndShollowCopy copy=new DeepAndShollowCopy(10,"Testing", list);
System.out.println(copy.toString());
}
@Override
public String toString() {
return "DeepAndShollowCopy [id=" + id + ", name=" + name + ", testlist=" + testlist + "]";
}
}
复制ararys：
Array是一个类，这意味着它是引用类型，因此array1 = array2结果 在两个引用相同数组的变量中。
但请看这个例子：
static void Main()
{
int[] arr1 = new int[] { 1, 2, 3, 4, 5 };
int[] arr2 = new int[] { 6, 7, 8, 9, 0 };
Console.WriteLine(arr1[2] + " " + arr2[2]);
arr2 = arr1;
Console.WriteLine(arr1[2] + " " + arr2[2]);
arr2 = (int[])arr1.Clone();
arr1[2] = 12;
Console.WriteLine(arr1[2] + " " + arr2[2]);
}
浅层克隆表示仅复制克隆数组表示的内存。
如果数组包含值类型对象，则复制值;
如果数组包含引用类型，则仅复制引用 - 因此，有两个数组的成员引用相同的对象。
要创建深层副本 - 其中引用类型是重复的，您必须遍历该数组并手动克隆每个元素。
添加到上述所有定义中，还有一个也是最常用的深层副本，位于类的复制构造函数（或重载赋值操作符）中。
浅拷贝 - ＆gt;是你不提供复制构造函数。在这里，只复制对象，但不会复制该类的所有成员。
深层复制 - ＆gt;是你决定在你的类中实现复制构造函数或重载赋值，并允许复制类的所有成员。
MyClass& MyClass(const MyClass& obj) // copy constructor for MyClass
{
// write your code, to copy all the members and return the new object
}
MyClass& operator=(const MyClass& obj) // overloading assignment operator,
{
// write your code, to copy all the members and return the new object
}
复制构造函数用于使用先前创建的同一类对象初始化新对象。默认情况下编译器写了一个浅拷贝。当没有涉及动态内存分配时，浅拷贝工作正常，因为当涉及动态内存分配时，两个对象都将指向堆中的相同内存位置。因此，为了消除此问题，我们编写了深层副本，因此两个对象都有自己的属性副本在记忆中。 为了通过完整的示例和解释阅读详细信息，您可以看到文章 C ++构造函数
为浅层复制之间的混淆添加一点，并简单地指定一个新的变量名列表。
“说我们有：
x = [
[1,2,3],
[4,5,6],
]
此语句创建3个列表：2个内部列表和1个外部列表。然后以名称x提供对外部列表的引用。如果我们这样做
y = x
没有数据被复制。我们在内存中仍然有相同的3个列表。除了之前的名称x之外，所有这一切都是使外部列表以名称y提供。如果我们这样做
y = list(x)
或
y = x[:]
这会创建一个与x相同内容的新列表。列表x包含对2个内部列表的引用，因此新列表还将包含对这2个内部列表的引用。只复制一个列表 - 外部列表。 现在内存中有4个列表，两个内部列表，外部列表和外部列表的副本。原始外部列表以名称x提供，新外部列表以名称y。
提供内部列表尚未复制！此时，您可以从x或y访问和编辑内部列表！
如果您有一个二维（或更高）列表或任何类型的嵌套数据结构，并且您想要制作所有内容的完整副本，那么您希望在复制模块中使用deepcopy（）函数。您的解决方案也适用于二维列表，迭代外部列表中的项目并制作每个列表的副本，然后为所有内部副本构建新的外部列表。“
