blocks|key|3956241|text|浅层副本尽可能少地复制。集合的浅副本是集合结构的副本，而不是元素的副本。通过浅层复制，两个集合现在共享单个元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3956242|深度拷贝会复制所有内容。集合的深层副本是两个集合，其中原始集合中的所有元素都重复。|3956243|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Shallow copies duplicate as little as possible. A shallow copy of a collection is a copy of the collection structure, not the elements. With a shallow copy, two collections now share the individual elements.

Deep copies duplicate everything. A deep copy of a collection is two collections with all of the elements in the original collection duplicated.

blocks|key|3956472|text|广度与深度；考虑以对象为根节点的引用树。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3956473|浅层：|3956474|​|3956475|📷|atomic|offset|length|3956476|3956477|3956478|3956479|变量A和B表示不同的内存区域，当B赋值给A时，两个变量表示相同的内存区域。稍后对其中任何一个的内容所做的修改都会立即反映在其他的内容中，因为它们共享内容。|3956480|深度：|3956481|3956482|3956483|3956484|3956485|3956486|变量A和B代表不同的内存区域，当B被赋值给A时，A指向的内存区域中的值被复制到B指向的内存区域。以后对A或B的内容所做的修改仍是唯一的；内容不共享。|3956487|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/2f16e4d2ec4968c94cad2a3409baf851.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/62709b6ba4b9b99600979afed0e32c41.png|2|https://ask.qcloudimg.com/http-save/yehe-900000/1efcb50695f0f2e79a27e6613ce34d66.png|3|https://ask.qcloudimg.com/http-save/yehe-900000/c411fdf190e9bd1444b3da35a1de957d.png|4|https://ask.qcloudimg.com/http-save/yehe-900000/91053ec783eef358dabef89ba086af0e.png|5|https://ask.qcloudimg.com/http-save/yehe-900000/1065819d71215544f21a5ad1e07e46e5.png^0|0|0|0|0|1|0|0|0|1|1|0|0|1|2|0|0|0|0|0|0|1|3|0|0|1|4|0|0|1|5|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1J|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1K|8|@]|9|@$I|1L|J|1M|1|1N]]|A|$]]|$1|K|3|G|5|H|7|1O|8|@]|9|@$I|1P|J|1Q|1|1R]]|A|$]]|$1|L|3|G|5|H|7|1S|8|@]|9|@$I|1T|J|1U|1|1V]]|A|$]]|$1|M|3|E|5|6|7|1W|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1X|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|R|3|E|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|S|3|G|5|H|7|20|8|@]|9|@$I|21|J|22|1|23]]|A|$]]|$1|T|3|G|5|H|7|24|8|@]|9|@$I|25|J|26|1|27]]|A|$]]|$1|U|3|G|5|H|7|28|8|@]|9|@$I|29|J|2A|1|2B]]|A|$]]|$1|V|3|E|5|6|7|2C|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2D|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15|16|-4]]|17|$5|11|12|13|A|$14|18|16|-4]]|19|$5|11|12|13|A|$14|1A|16|-4]]|1B|$5|11|12|13|A|$14|1C|16|-4]]|1D|$5|11|12|13|A|$14|1E|16|-4]]|1F|$5|11|12|13|A|$14|1G|16|-4]]]]

Breadth vs Depth; think in terms of a tree of references with your object as the root node.
Shallow:
<img src="https://i.stack.imgur.com/49psq.png" alt="Before Copy" /> <img src="https://i.stack.imgur.com/qqE2L.png" alt="Shallow Copying" /> <img src="https://i.stack.imgur.com/cys27.png" alt="Shallow Done" />
The variables A and B refer to different areas of memory, when B is assigned to A the two variables refer to the same area of memory. Later modifications to the contents of either are instantly reflected in the contents of other, as they share contents.
Deep:
<img src="https://i.stack.imgur.com/DRLn7.png" alt="Before Copy" /> <img src="https://i.stack.imgur.com/yuURM.png" alt="Deep Copying" /> <img src="https://i.stack.imgur.com/i6yAt.png" alt="Deep Done" />
The variables A and B refer to different areas of memory, when B is assigned to A the values in the memory area which A points to are copied into the memory area to which B points. Later modifications to the contents of either remain unique to A or B; the contents are not shared.

blocks|key|5366002|text|简而言之，这取决于什么指向什么。在浅层复制中，对象B指向对象A在内存中的位置。在深度复制中，对象A的内存位置中的所有内容都被复制到对象B的内存位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5366003|这篇维基文章有一个很棒的图表。|5366004|http://en.wikipedia.org/wiki/Object_copy|offset|length|5366005|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|14|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

In short, it depends on what points to what. In a shallow copy, object B points to object A's location in memory. In deep copy, all things in object A's memory location get copied to object B's memory location.

This wiki article has a great diagram.

<a href="http://en.wikipedia.org/wiki/Object_copy" rel="noreferrer">http://en.wikipedia.org/wiki/Object_copy</a>

blocks|key|3957390|text|试着考虑下图|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3957391|​|3957392|📷|atomic|offset|length|3957393|3957394|例如，Object.MemberwiseClone会创建一个shallow+copy+link|style|BOLD|3957395|使用ICloneable界面，您可以获得如here所述的deep+copy|3957396|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/a84f418f14c6e4345790596687696b61.jpeg|imageAlt|1|LINK|MUTABLE|url|https://msdn.microsoft.com/en-us/library/system.object.memberwiseclone(v=vs.110).aspx|2|https://stackoverflow.com/a/78612/1074179^0|0|0|0|1|0|0|0|3|M|U|7|17|4|1|0|2|A|S|4|L|4|2|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@$G|18|H|19|1|1A]]|A|$]]|$1|I|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1C|8|@$G|1D|H|1E|L|M]|$G|1F|H|1G|L|M]]|9|@$G|1H|H|1I|1|1J]]|A|$]]|$1|N|3|O|5|6|7|1K|8|@$G|1L|H|1M|L|M]|$G|1N|H|1O|L|M]]|9|@$G|1P|H|1Q|1|1R]]|A|$]]|$1|P|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W|X|-4]]|Y|$5|Z|T|10|A|$11|12]]|13|$5|Z|T|10|A|$11|14]]]]

Try to consider following image

<a href="https://i.stack.imgur.com/AWKJa.jpg" rel="noreferrer"><img src="https://i.stack.imgur.com/AWKJa.jpg" alt="enter image description here"></a>

For example Object.MemberwiseClone creates a shallow copy <a href="https://msdn.microsoft.com/en-us/library/system.object.memberwiseclone(v=vs.110).aspx" rel="noreferrer">link</a>

and using ICloneable interface you can get deep copy as described <a href="https://stackoverflow.com/a/78612/1074179">here</a>

blocks|key|3956675|text|专为iOS开发人员准备的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3956676|如果B是的A浅拷贝，那么对于原始数据，它就像B+=+[A+assign];，而对于对象，它就像B+=+[A+retain]；|CODE|3956677|B和A指向相同的内存位置|3956678|如果B是的A深度拷贝，那么它类似于B+=+[A+copy];|3956679|B和A指向不同的内存位置|3956680|B内存地址与A内存地址相同|3956681|B的内容与A的相同|3956682|entityMap^0|C|1|0|2|1|5|1|M|F|1B|E|4|5|0|0|2|1|5|1|H|D|4|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|H]|$9|10|A|11|B|H]|$9|12|A|13|B|H]|$9|14|A|15|B|H]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|18|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|19|8|@$9|1A|A|1B|B|H]|$9|1C|A|1D|B|H]|$9|1E|A|1F|B|H]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1I|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1J|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1K|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|T|$]]

Especially For iOS Developers: 

If <code>B</code> is a shallow copy of <code>A</code>, then for primitive data it's like <code>B = [A assign];</code> and for objects it's like <code>B = [A retain]</code>;

B and A point to the same memory location

If <code>B</code> is a deep copy of <code>A</code>, then it is like <code>B = [A copy];</code>

B and A point to different memory locations

B memory address is same as A's

B has same contents as A's

blocks|key|3956205|text|浅层复制:将成员值从一个对象复制到另一个对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3956206|深度复制:将成员值从一个对象复制到另一个对象。|3956207|任何指针对象都会被复制和深度复制。|3956208|示例：|3956209|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.)|code-block|syntax|javascript|3956210|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Shallow copy:&nbsp;Copies the member values from one object into another.

Deep Copy:&nbsp;&nbsp;&nbsp;&nbsp;Copies the member values from one object into another. 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Any pointer objects are duplicated and Deep Copied.

Example:

<pre><code>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.)
</code></pre>

blocks|key|5366987|text|为了便于理解，您可以阅读本文：https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying.htm|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5366988|5366989|浅拷贝：|style|BOLD|5366990|​|5366991|📷|atomic|5366992|5366993|深度复制：|5366994|5366995|5366996|5366997|entityMap|0|LINK|mutability|MUTABLE|url|https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying.htm|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/05b5d8c86d25275fafa70d306d196d02.gif|imageAlt|2|https://ask.qcloudimg.com/http-save/yehe-900000/4c98f2f841b3715cb8628d4d9b8d266a.gif^0|F|1S|0|0|0|0|4|0|0|0|1|1|0|0|0|5|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]|$1|E|3|F|5|6|7|1E|8|@$A|1F|B|1G|G|H]]|9|@]|C|$]]|$1|I|3|J|5|6|7|1H|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|N|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1N|8|@$A|1O|B|1P|G|H]]|9|@]|C|$]]|$1|Q|3|J|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|R|3|L|5|M|7|1R|8|@]|9|@$A|1S|B|1T|1|1U]]|C|$]]|$1|S|3|J|5|6|7|1V|8|@]|9|@]|C|$]]|$1|T|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]]|U|$V|$5|W|X|Y|C|$Z|10]]|11|$5|12|X|13|C|$14|15|16|-4]]|17|$5|12|X|13|C|$14|18|16|-4]]]]

Just for the sake of easy understanding you could follow this article:
<a href="https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying.htm">https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying.htm</a>

<hr>

Shallow Copy:

<a href="https://i.stack.imgur.com/nJJ6K.gif"><img src="https://i.stack.imgur.com/nJJ6K.gif" alt="Shallow Copy"></a> 

<hr>

Deep Copy:

<a href="https://i.stack.imgur.com/R6Jlg.gif"><img src="https://i.stack.imgur.com/R6Jlg.gif" alt="Deep Copy"></a>

blocks|key|808136|text|我在这里还没有看到一个简短、易于理解的答案--所以我将试一试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|808137|使用浅层复制时，源指向的任何对象也会被目标指向(这样就不会复制被引用的对象)。|808138|使用深度复制时，源指向的任何对象都会被复制，而目标指向的是副本(因此现在每个引用的对象将有2个)。这会在对象树中向下递归。|808139|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I haven't seen a short, easy to understand answer here--so I'll give it a try.

With a shallow copy, any object pointed to by the source is also pointed to by the destination (so that no referenced objects are copied).

With a deep copy, any object pointed to by the source is copied and the copy is pointed to by the destination (so there will now be 2 of each referenced object). This recurses down the object tree.

blocks|key|812594|text|{假设有两个对象:A和B是同一类型的_t(相对于C%2B%2B)，并且您正在考虑将A复制到B的浅/深复制}|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812595|浅复制：只是将对A的引用复制到B中。可以将其视为A的地址的副本。因此，A和B的地址将是相同的，即它们将指向相同的存储位置，即数据内容。|offset|length|style|BOLD|812596|深度复制：简单地复制A的所有成员，将内存分配到B的不同位置，然后将复制的成员分配给B以实现深度复制。这样，如果A变得不存在，B在内存中仍然有效。正确的术语应该是克隆，在这种情况下，您知道它们完全相同，但又不同(即作为两个不同的实体存储在内存空间中)。您还可以提供克隆包装器，您可以在其中通过包含/排除列表决定在深度复制期间选择哪些属性。在创建API时，这是一种相当常见的做法。|812597|你可以选择做一个浅拷贝ONLY_IF，如果你了解其中的风险的话。当你在C%2B%2B或C中有大量的指针要处理时，对一个对象做一个浅拷贝()真的是一个糟糕的主意。|812598|EXAMPLE_OF_DEEP+COPY_的一个例子是，当您尝试进行图像处理和对象识别时，您需要将“无关和重复的运动”屏蔽在处理区域之外。如果您使用的是图像指针，那么您可能具有保存这些遮罩图像的规范。现在..。如果你对图像做一个浅层拷贝，当指针引用从堆栈中删除时，你就会丢失引用及其副本，即在某个时刻会出现访问冲突的运行时错误。在这种情况下，您需要的是通过克隆映像的深度副本。通过这种方式，您可以在将来需要时检索掩码。|812599|与StackOverflow中的用户相比，EXAMPLE_OF_SHALLOW_COPY我的知识不是很丰富，所以如果你可以澄清，请随意删除这一部分，并提供一个很好的例子。但我真的认为，如果你知道你的程序将运行无限的时间，即通过函数调用对堆栈进行连续的“推送-弹出”操作，那么进行浅拷贝并不是一个好主意。如果你正在向一个业余或新手演示一些东西(例如C/C%2B%2B教程之类的东西)，那么这可能是可以的。但是，如果你正在运行一个应用程序，比如监视和检测系统，或者声纳跟踪系统，你不应该一直浅显地复制你的对象，因为它迟早会杀死你的程序。|812600|entityMap^0|0|0|4|0|0|5|0|B|7|0|0|L|0|L|N|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|14|8|@$D|15|E|16|F|G]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|Q|$]]

{Imagine two objects: A and B of same type _t(with respect to C++) and you are thinking about shallow/deep copying A to B}

Shallow Copy:
Simply makes a copy of the reference to A into B. Think about it as a copy of A's Address.
So, the addresses of A and B will be the same i.e. they will be pointing to the same memory location i.e. data contents.

Deep copy:
Simply makes a copy of all the members of A, allocates memory in a different location for B and then assigns the copied members to B to achieve deep copy. In this way, if A becomes non-existant B is still valid in the memory. The correct term to use would be cloning, where you know that they both are totally the same, but yet different (i.e. stored as two different entities in the memory space). You can also provide your clone wrapper where you can decide via inclusion/exclusion list which properties to select during deep copy. This is quite a common practice when you create APIs.

You can choose to do a Shallow Copy ONLY_IF you understand the stakes involved. When you have enormous number of pointers to deal with in C++ or C, doing a shallow copy of an object is REALLY a bad idea. 

EXAMPLE_OF_DEEP COPY_ An example is, when you are trying to do image processing and object recognition you need to mask "Irrelevant and Repetitive Motion" out of your processing areas. If you are using image pointers, then you might have the specification to save those mask images. NOW... if you do a shallow copy of the image, when the pointer references are KILLED from the stack, you lost the reference and its copy i.e. there will be a runtime error of access violation at some point. In this case, what you need is a deep copy of your image by CLONING it. In this way you can retrieve the masks in case you need them in the future.

EXAMPLE_OF_SHALLOW_COPY I am not extremely knowledgeable compared to the users in StackOverflow so feel free to delete this part and put a good example if you can clarify. But I really think it is not a good idea to do shallow copy if you know that your program is gonna run for an infinite period of time i.e. continuous "push-pop" operation over the stack with function calls. If you are demonstrating something to an amateur or novice person (e.g. C/C++ tutorial stuff) then it is probably okay. But if you are running an application such as surveillance and detection system, or Sonar Tracking System, you are not supposed to keep shallow copying your objects around because it will kill your program sooner or later.

blocks|key|5366115|text|char+*+Source+=+"Hello,+world.";

char+*+ShallowCopy+=+Source;++++

char+*+DeepCopy+=+new+char(strlen(Source)%2B1);
strcpy(DeepCopy,Source);++++++++|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5366116|“ShallowCopy”指向内存中与“Source”相同的位置。“DeepCopy”指向内存中的不同位置，但内容是相同的。|unstyled|5366117|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>char * Source = "Hello, world.";

char * ShallowCopy = Source; 

char * DeepCopy = new char(strlen(Source)+1);
strcpy(DeepCopy,Source); 
</code></pre>

'ShallowCopy' points to the same location in memory as 'Source' does.
'DeepCopy' points to a different location in memory, but the contents are the same.

blocks|key|3957200|text|什么是浅层复制？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3957201|浅拷贝是对象的逐位拷贝。将创建一个新对象，该对象具有原始对象中的值的精确副本。如果对象的任何字段是对其他对象的引用，则仅复制引用地址，即，仅复制存储器地址。|3957202|📷|atomic|3957203|​|3957204|在此图中，MainObject1具有类型为int的字段field1和类型为ContainObject的字段ContainObject1。当您执行MainObject1的浅层复制时，将使用field2创建MainObject2，其中包含field1的复制值，并且仍然指向ContainObject1本身。注意，因为field1是原始类型，所以它的值被复制到field2，但是因为ContainedObject1是一个对象，所以MainObject2仍然指向ContainObject1。因此，在MainObject1中对ContainObject1所做的任何更改都将反映在MainObject2中。|CODE|3957205|现在，如果这是浅拷贝，让我们看看什么是深拷贝？|3957206|什么是深度复制？|3957207|深度复制复制所有字段，并复制这些字段所指向的动态分配的内存。当一个对象与它所引用的对象一起复制时，就会发生深度复制。|3957208|3957209|3957210|在此图中，MainObject1具有类型为int的字段field1和类型为ContainObject的ContainObject1。执行MainObject1的深度复制时，将使用包含field1的复制值的field2和包含ContainObject1的复制值的ContainObject2创建MainObject2。注意:在MainObject1中对ContainObject1所做的任何更改都不会反映在MainObject2中。|3957211|good+article|3957212|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/9a75c41f8fa0c046d710f7fc655bda79.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/6bb5b313940a82aa1264077c5031a53b.png|2|LINK|MUTABLE|url|http://www.jusfortechies.com/java/core-java/deepcopy_and_shallowcopy.php^0|0|8|0|0|0|1|0|0|0|5|B|R|6|11|D|1H|E|20|B|2L|6|2T|B|39|6|3Q|E|4C|6|4X|6|58|G|5W|B|6B|E|6U|B|77|E|7X|B|0|0|0|8|0|0|0|1|1|0|0|R|6|11|D|1F|E|1W|B|2J|6|2U|6|33|E|3M|E|42|B|4I|B|4V|E|5M|B|0|0|C|2|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1K|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|K|3|L|5|6|7|1P|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1Q|8|@$9|1R|A|1S|B|O]|$9|1T|A|1U|B|O]|$9|1V|A|1W|B|O]|$9|1X|A|1Y|B|O]|$9|1Z|A|20|B|O]|$9|21|A|22|B|O]|$9|23|A|24|B|O]|$9|25|A|26|B|O]|$9|27|A|28|B|O]|$9|29|A|2A|B|O]|$9|2B|A|2C|B|O]|$9|2D|A|2E|B|O]|$9|2F|A|2G|B|O]|$9|2H|A|2I|B|O]|$9|2J|A|2K|B|O]|$9|2L|A|2M|B|O]|$9|2N|A|2O|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|2P|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|2Q|8|@$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|2T|8|@]|D|@]|E|$]]|$1|V|3|I|5|J|7|2U|8|@]|D|@$9|2V|A|2W|1|2X]]|E|$]]|$1|W|3|L|5|6|7|2Y|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2Z|8|@$9|30|A|31|B|O]|$9|32|A|33|B|O]|$9|34|A|35|B|O]|$9|36|A|37|B|O]|$9|38|A|39|B|O]|$9|3A|A|3B|B|O]|$9|3C|A|3D|B|O]|$9|3E|A|3F|B|O]|$9|3G|A|3H|B|O]|$9|3I|A|3J|B|O]|$9|3K|A|3L|B|O]|$9|3M|A|3N|B|O]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|3O|8|@]|D|@$9|3P|A|3Q|1|3R]]|E|$]]|$1|11|3|-4|5|6|7|3S|8|@]|D|@]|E|$]]]|12|$13|$5|14|15|16|E|$17|18|19|-4]]|1A|$5|14|15|16|E|$17|1B|19|-4]]|1C|$5|1D|15|1E|E|$1F|1G]]]]

What is Shallow Copy?

Shallow copy is a bit-wise copy of an object. A new object is created that has an exact copy of the values in the original object. If any of the fields of the object are references to other objects, only the reference addresses are copied i.e., only the memory address is copied. <img src="https://i.stack.imgur.com/LnDQh.png" alt="Shallow Copy">

In this figure, the <code>MainObject1</code> has fields <code>field1</code> of type int, and <code>ContainObject1</code> of type <code>ContainObject</code>. When you do a shallow copy of <code>MainObject1</code>, <code>MainObject2</code> is created with <code>field2</code> containing the copied value of <code>field1</code> and still pointing to <code>ContainObject1</code> itself. Note that since <code>field1</code> is of primitive type, its value is copied to <code>field2</code> but since <code>ContainedObject1</code> is an object, <code>MainObject2</code> still points to <code>ContainObject1</code>. So any changes made to <code>ContainObject1</code> in <code>MainObject1</code> will be reflected in <code>MainObject2</code>.

Now if this is shallow copy, lets see what's deep copy? 

What is Deep Copy?

A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to by the fields. A deep copy occurs when an object is copied along with the objects to which it refers. 
<img src="https://i.stack.imgur.com/kocda.png" alt="Deep Copy">

In this figure, the MainObject1 have fields <code>field1</code> of type int, and <code>ContainObject1</code> of type <code>ContainObject</code>. When you do a deep copy of <code>MainObject1</code>, <code>MainObject2</code> is created with <code>field2</code> containing the copied value of <code>field1</code> and <code>ContainObject2</code> containing the copied value of <code>ContainObject1</code>. Note any changes made to <code>ContainObject1</code> in <code>MainObject1</code> will not reflect in <code>MainObject2</code>. 

<a href="http://www.jusfortechies.com/java/core-java/deepcopy_and_shallowcopy.php" rel="noreferrer">good article</a>

blocks|key|3956517|text|在面向对象编程中，类型包括成员字段的集合。这些字段可以通过值或通过引用(即，指向值的指针)来存储。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3956518|在浅层复制中，将创建该类型的新实例，并将值复制到新实例中。引用指针也会像值一样被复制。因此，引用指向原始对象。对通过引用存储的成员所做的任何更改都会同时出现在原始和副本中，因为没有为被引用的对象制作副本。|3956519|在深度复制中，按值存储的字段将像以前一样进行复制，但不会复制按引用存储的对象指针。相反，将创建被引用对象的深层副本，并存储指向新对象的指针。对这些被引用对象所做的任何更改都不会影响该对象的其他副本。|3956520|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

In object oriented programming, a type includes a collection of member fields. These fields may be stored either by value or by reference (i.e., a pointer to a value).

In a shallow copy, a new instance of the type is created and the values are copied into the new instance. The reference pointers are also copied just like the values. Therefore, the references are pointing to the original objects. Any changes to the members that are stored by reference appear in both the original and the copy, since no copy was made of the referenced object.

In a deep copy, the fields that are stored by value are copied as before, but the pointers to objects stored by reference are not copied. Instead, a deep copy is made of the referenced object, and a pointer to the new object is stored. Any changes that are made to those referenced objects will not affect other copies of the object.

blocks|key|5366423|text|“ShallowCopy”指向内存中与“Source”相同的位置。“DeepCopy”指向内存中的不同位置，但内容是相同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5366424|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

'ShallowCopy' points to the same location in memory as 'Source' does. 'DeepCopy' points to a different location in memory, but the contents are the same.

blocks|key|5367014|text|深度复制|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5367015|深度复制复制所有字段，并复制这些字段所指向的动态分配的内存。当一个对象与它所引用的对象一起复制时，就会发生深度复制。|5367016|浅层复制|5367017|浅拷贝是对象的逐位拷贝。将创建一个新对象，该对象具有原始对象中的值的精确副本。如果对象的任何字段是对其他对象的引用，则仅复制引用地址，即，仅复制存储器地址。|5367018|entityMap^0|0|4|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|U|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|M|$]]

Deep Copy

A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to by the fields. A deep copy occurs when an object is copied along with the objects to which it refers. 

Shallow Copy

Shallow copy is a bit-wise copy of an object. A new object is created that has an exact copy of the values in the original object. If any of the fields of the object are references to other objects, just the reference addresses are copied i.e., only the memory address is copied.

blocks|key|3957653|text|浅克隆：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3957654|定义：“对象的浅层副本复制‘主’对象，但不复制内部对象。”当自定义对象(例如，Employee)只有原始的、字符串类型的变量，然后使用浅克隆。|3957655|Employee+e+=+new+Employee(2,+"john+cena");
Employee+e2=e.clone();|code-block|syntax|javascript|3957656|在被覆盖的super.clone();+()方法中返回克隆，作业就结束了。|CODE|3957657|深度克隆|3957658|定义：“与浅层拷贝不同，深层拷贝是对象的完全独立拷贝。”|3957659|表示当一个Employee对象持有另一个自定义对象时：|3957660|Employee+e+=+new+Employee(2,+"john+cena",+new+Address(12,+"West+Newbury",+"Massachusetts");|3957661|然后，您必须在被覆盖的clone()方法中编写代码来克隆'Address‘对象。否则，Address对象将无法克隆，当您更改克隆的Employee对象中的Address值时，它会导致错误，这也反映了原始的值。|3957662|entityMap^0|0|4|0|0|0|5|E|0|0|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@$9|17|A|18|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1C|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1D|8|@]|D|@]|E|$]]|$1|V|3|W|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|X|3|Y|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|10|$]]

Shallow Cloning: 
Definition: "A shallow copy of an object copies the ‘main’ object, but doesn’t copy the inner objects." 
When a custom object (eg. Employee) has just primitive, String type variables then you use Shallow Cloning. 

<pre><code>Employee e = new Employee(2, "john cena");
Employee e2=e.clone();
</code></pre>

You return <code>super.clone();</code> in the overridden clone() method and your job is over.

Deep Cloning: 
Definition: "Unlike the shallow copy, a deep copy is a fully independent copy of an object." 
Means when an Employee object holds another custom object: 

<pre><code>Employee e = new Employee(2, "john cena", new Address(12, "West Newbury", "Massachusetts");
</code></pre>

Then you have to write the code to clone the 'Address' object as well in the overridden clone() method. Otherwise the Address object won't clone and it causes a bug when you change value of Address in cloned Employee object, which reflects the original one too.

blocks|key|3957956|text|我想举个例子，而不是正式的定义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3957957|var+originalObject+=+{+
++++a+:+1,+
++++b+:+2,+
++++c+:+3,
};|code-block|syntax|javascript|3957958|此代码显示了一个浅拷贝|offset|length|style|BOLD|3957959|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|3957960|此代码显示了一个深度复制|3957961|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+!!|3957962|entityMap^0|0|0|8|3|0|0|8|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

I would like to give example rather than the formal definition.

<pre><code>var originalObject = { 
 a : 1, 
 b : 2, 
 c : 3,
};
</code></pre>

This code shows a shallow copy:

<pre><code>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
</code></pre>

This code shows a deep copy:

<pre><code>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 !!
</code></pre>

blocks|key|5366119|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5366120|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

blocks|key|5367177|text|浅复制-原始对象和浅复制对象中的引用变量都引用了公共对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5367178|深度复制-原始对象和深度复制对象中的引用变量都引用了不同的对象。|5367179|5367180|克隆始终执行浅拷贝。|blockquote|5367181|5367182|5367183|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();
++++}
}|code-block|syntax|javascript|5367184|主类如下-|5367185|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%2B%2B)
++++++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%2B%2B)
++++++++++System.out.println(list.get(i)==deep.get(i));//false
++++++
}+|5367186|以上的OutPut将是-|5367187|5367188|+false+true+true|5367189|5367190|错误|5367191|5367192|在原始对象中所做的任何更改都将反映在浅层对象中，而不是深层对象中。|5367193|++list.get(0).name="ViSuaLBaSiC";
++System.out.println(shallow.get(0).getName()%2B"++"%2Bdeep.get(0).getName());|5367194|输出-+ViSuaLBaSiC+C|5367195|entityMap^0|0|3|O|2|0|0|4|Q|3|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1O|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1R|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|1S|8|@]|D|@]|E|$]]|$1|U|3|V|5|P|7|1T|8|@]|D|@]|E|$Q|R]]|$1|W|3|X|5|6|7|1U|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]|$1|Z|3|10|5|K|7|1W|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|20|8|@]|D|@]|E|$]]|$1|17|3|18|5|P|7|21|8|@]|D|@]|E|$Q|R]]|$1|19|3|1A|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|1C|$]]

Shallow Copy- Reference variable inside original and shallow-copied objects have reference to common object.
Deep Copy- Reference variable inside original and deep-copied objects have reference to different object.
<blockquote>
clone always does shallow copy.
</blockquote>
<pre><code>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();
 }
}
</code></pre>
main class is following-
<pre><code>public static void main(String args[]) throws ClassNotFoundException, CloneNotSupportedException{

 ArrayList&lt;Language&gt; list=new ArrayList&lt;Language&gt;();
 list.add(new Language(&quot;C&quot;));
 list.add(new Language(&quot;JAVA&quot;));

 ArrayList&lt;Language&gt; shallow=(ArrayList&lt;Language&gt;) list.clone();
 //We used here clone since this always shallow copied.

 System.out.println(list==shallow);
 
 for(int i=0;i&lt;list.size();i++)
 System.out.println(list.get(i)==shallow.get(i));//true
 
 ArrayList&lt;Language&gt; deep=new ArrayList&lt;Language&gt;();
 for(Language language:list){
 deep.add((Language) language.clone());
 }
 System.out.println(list==deep);
 for(int i=0;i&lt;list.size();i++)
 System.out.println(list.get(i)==deep.get(i));//false
 
} 
</code></pre>
OutPut of above will be-
<blockquote>
false true true
false false false
</blockquote>
Any change made in origional object will reflect in shallow object not in deep object.
<pre><code> list.get(0).name=&quot;ViSuaLBaSiC&quot;;
 System.out.println(shallow.get(0).getName()+&quot; &quot;+deep.get(0).getName());
</code></pre>
OutPut- ViSuaLBaSiC C

blocks|key|5367239|text|假设有两个名为arr1和arr2的数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5367240|arr1+=+arr2;+++//shallow+copy
arr1+=+arr2.clone();+//deep+copy|code-block|syntax|javascript|5367241|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Imagine there are two arrays called arr1 and arr2. 

<pre><code>arr1 = arr2; //shallow copy
arr1 = arr2.clone(); //deep copy
</code></pre>

blocks|key|812522|text|简单地说，浅复制类似于按引用调用，而深复制类似于按值调用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812523|在按引用调用中，函数的形参和实参都引用相同的内存位置和值。|812524|在按值调用中，函数的形式参数和实际参数都引用不同的内存位置，但具有相同的值。|812525|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

In Simple Terms, a Shallow Copy is similar to Call By Reference and a Deep Copy is similar to Call By Value

In Call By Reference, Both formal and actual parameters of a function refers to same memory location and the value.

In Call By Value, Both formal and actual parameters of a functions refers to different memory location but having the same value.

blocks|key|3957773|text|浅拷贝构造一个新的复合对象，并在其中插入对原始对象的引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3957774|与浅层复制不同，深度复制构造新的复合对象，并插入原始复合对象的原始对象的副本。|3957775|让我们举个例子。|3957776|import+copy
x+=[1,[2]]
y=copy.copy(x)
z=+copy.deepcopy(x)
print(y+is+z)|code-block|syntax|javascript|3957777|上面的代码输出为FALSE。|3957778|让我们看看是怎么做的。|3957779|原始复合对象x=[1,[2]]+(称为复合，因为它在对象内部有对象(初始))|offset|length|style|CODE|3957780|​|3957781|📷|atomic|3957782|3957783|正如您在图像中所看到的，list中有一个列表。|3957784|然后我们使用y+=+copy.copy(x)创建它的浅层副本。python在这里做的是，它将创建一个新的复合对象，但其中的对象指向原始对象。|3957785|3957786|3957787|3957788|在图像中，它为外部列表创建了一个新的副本。但内部列表保持与原始列表相同。|3957789|现在我们使用z+=+copy.deepcopy(x)创建它的深度副本。python在这里做的是，它将为外部列表和内部列表创建新的对象。如下图所示(红色高亮显示)。|3957790|3957791|3957792|3957793|最后，代码打印False，因为y和z是不同的对象。|3957794|HTH。|3957795|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/c9328af8775a27a13f7e08a811cac85b.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/daee507adcf2e91fa7a04f49556f5180.png|2|https://ask.qcloudimg.com/http-save/yehe-900000/85a31a44fb43aacf035bf063b62239ad.png^0|0|0|0|0|0|0|6|9|0|0|0|1|0|0|0|0|6|G|0|0|0|1|1|0|0|0|6|K|0|0|0|1|2|0|0|7|5|0|0^^$0|@$1|2|3|4|5|6|7|1V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1X|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1Y|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|20|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|21|8|@$Q|22|R|23|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|24|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|25|8|@]|9|@$Q|26|R|27|1|28]]|A|$]]|$1|Z|3|V|5|6|7|29|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2A|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2B|8|@$Q|2C|R|2D|S|T]]|9|@]|A|$]]|$1|14|3|V|5|6|7|2E|8|@]|9|@]|A|$]]|$1|15|3|X|5|Y|7|2F|8|@]|9|@$Q|2G|R|2H|1|2I]]|A|$]]|$1|16|3|V|5|6|7|2J|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|2K|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|2L|8|@$Q|2M|R|2N|S|T]]|9|@]|A|$]]|$1|1B|3|V|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1C|3|X|5|Y|7|2P|8|@]|9|@$Q|2Q|R|2R|1|2S]]|A|$]]|$1|1D|3|V|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2U|8|@$Q|2V|R|2W|S|T]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1I|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]]|1J|$1K|$5|1L|1M|1N|A|$1O|1P|1Q|-4]]|1R|$5|1L|1M|1N|A|$1O|1S|1Q|-4]]|1T|$5|1L|1M|1N|A|$1O|1U|1Q|-4]]]]

A shallow copy constructs a new compound object and insert its references into it to the original object.

Unlike shallow copy, deepcopy constructs new compound object and also inserts copies of the original objects of original compound object.

Lets take an example.

<pre><code>import copy
x =[1,[2]]
y=copy.copy(x)
z= copy.deepcopy(x)
print(y is z)
</code></pre>

Above code prints FALSE.

Let see how.

Original compound object <code>x=[1,[2]]</code> (called as compound because it has object inside object (Inception))

<a href="https://i.stack.imgur.com/QtsjW.png" rel="noreferrer"><img src="https://i.stack.imgur.com/QtsjW.png" alt="enter image description here"></a>

as you can see in the image, there is a list inside list.

Then we create a shallow copy of it using <code>y = copy.copy(x)</code>. What python does here is, it will create a new compound object but objects inside them are pointing to the orignal objects.

<a href="https://i.stack.imgur.com/QLeDN.png" rel="noreferrer"><img src="https://i.stack.imgur.com/QLeDN.png" alt="enter image description here"></a>

In the image it has created a new copy for outer list. but the inner list remains same as the original one.

Now we create deepcopy of it using <code>z = copy.deepcopy(x)</code>. what python does here is, it will create new object for outer list as well as inner list. as shown in the image below (red highlighted).

<a href="https://i.stack.imgur.com/4fYHO.png" rel="noreferrer"><img src="https://i.stack.imgur.com/4fYHO.png" alt="enter image description here"></a>

At the end code prints <code>False</code>, as y and z are not same objects.

HTH.

blocks|key|3956544|text|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)%2B1);
++++memcpy(dest.ptr,src.ptr);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3956545|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>struct sample
{
 char * ptr;
}
void shallowcpy(sample &amp; dest, sample &amp; src)
{
 dest.ptr=src.ptr;
}
void deepcpy(sample &amp; dest, sample &amp; src)
{
 dest.ptr=malloc(strlen(src.ptr)+1);
 memcpy(dest.ptr,src.ptr);
}
</code></pre>

blocks|key|812967|text|要向其他答案添加更多内容，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812968|812969|对象的浅层副本对基于值类型的属性执行按值复制，对基于引用类型的属性执行按引用复制。|unordered-list-item|812970|对象的深层副本对基于值类型的属性执行按值复制，对层次结构(引用类型)中深层的基于引用类型的属性执行按值复制|812971|812972|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|M|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|N|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

To add more to other answers, 

<ul>
<li>a Shallow Copy of an object performs copy by value for value types
based properties, and copy by reference for reference types based properties.</li>
<li>a Deep Copy of an object performs copy by value for value types based
properties, as well as copy by value for reference types based
properties deep in the hierarchy (of reference types)</li>
</ul>

blocks|key|3957590|text|浅复制不会创建新引用，但深复制将创建新引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3957591|下面是解释深拷贝和浅拷贝的程序。|3957592|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%2B%2B");
++++++++DeepAndShollowCopy+copy=new+DeepAndShollowCopy(10,"Testing",+list);
++++++++System.out.println(copy.toString());
++++}
++++@Override
++++public+String+toString()+{
++++++++return+"DeepAndShollowCopy+[id="+%2B+id+%2B+",+name="+%2B+name+%2B+",+testlist="+%2B+testlist+%2B+"]";
++++}
}|code-block|syntax|javascript|3957593|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Shallow copy will not create new reference but deep copy will create the new reference.

Here is the program to explain the deep and shallow copy.

<pre class="lang-java prettyprint-override"><code>public class DeepAndShollowCopy {
 int id;
 String name;
 List&lt;String&gt; testlist = new ArrayList&lt;&gt;();

 /*
 // To performing Shallow Copy 
 // Note: Here we are not creating any references. 
 public DeepAndShollowCopy(int id, String name, List&lt;String&gt;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&lt;String&gt; testlist) {
 System.out.println("Deep Copy for Object initialization");
 this.id = id;
 this.name = name;
 String item;
 List&lt;String&gt; Al = new ArrayList&lt;&gt;();
 Iterator&lt;String&gt; itr = testlist.iterator();
 while (itr.hasNext()) {
 item = itr.next();
 Al.add(item);
 }
 this.testlist = Al;
 }


 public static void main(String[] args) {
 List&lt;String&gt; list = new ArrayList&lt;&gt;();
 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 + "]";
 }
}
</code></pre>

blocks|key|3111486|text|摘自博客：http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3111487|深度复制涉及到使用一个对象的内容来创建同一类的另一个实例。在深度复制中，两个对象可能包含相同的信息，但目标对象将具有自己的缓冲区和资源。销毁任何一个对象都不会影响剩余的对象。重载的赋值操作符将创建对象的深层副本。|style|BOLD|3111488|浅复制涉及到将一个对象的内容复制到同一个类的另一个实例中，从而创建镜像。由于直接复制引用和指针，这两个对象将共享另一个对象的相同外部包含内容，这是不可预测的。|3111489|说明：|3111490|使用复制构造函数，我们只需逐个复制数据值。这种复制方法称为浅层复制。如果对象是一个简单的类，由内置类型组成，没有指针，这是可以接受的。此函数将使用值和对象，其行为不会因浅层复制而改变，只复制成员指针的地址，而不复制地址所指向的值。然后，对象的数据值将被该函数无意中改变。当函数超出作用域时，对象的副本及其所有数据将从堆栈中弹出。|3111491|如果对象有任何指针，则需要执行深度复制。对于对象的深度复制，将为空闲存储中的对象分配内存，并复制指向的元素。深层副本用于从函数返回的对象。|3111492|entityMap|0|LINK|mutability|MUTABLE|url|http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html^0|5|2G|0|0|0|4|0|0|3|0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@$A|12|B|13|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|14|8|@$A|15|B|16|F|G]]|9|@]|C|$]]|$1|J|3|K|5|6|7|17|8|@$A|18|B|19|F|G]]|9|@]|C|$]]|$1|L|3|M|5|6|7|1A|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

Taken from [blog]: <a href="http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html" rel="nofollow">http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html</a>

Deep copy involves using the contents of one object to create another instance of the same class. In a deep copy, the two objects may contain ht same information but the target object will have its own buffers and resources. the destruction of either object will not affect the remaining object. The overloaded assignment operator would create a deep copy of objects.

Shallow copy involves copying the contents of one object into another instance of the same class thus creating a mirror image. Owing to straight copying of references and pointers, the two objects will share the same externally contained contents of the other object to be unpredictable.

Explanation:

Using a copy constructor we simply copy the data values member by member. This method of copying is called shallow copy. If the object is a simple class, comprised of built in types and no pointers this would be acceptable. This function would use the values and the objects and its behavior would not be altered with a shallow copy, only the addresses of pointers that are members are copied and not the value the address is pointing to. The data values of the object would then be inadvertently altered by the function. When the function goes out of scope, the copy of the object with all its data is popped off the stack.

If the object has any pointers a deep copy needs to be executed. With the deep copy of an object, memory is allocated for the object in free store and the elements pointed to are copied. A deep copy is used for objects that are returned from a function.

blocks|key|5368002|text|我从以下几行中理解了这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5368003|浅复制将对象值类型(整型、浮点型、布尔型)字段复制到目标对象中，并且对象的引用类型(字符串、类等)被复制为目标对象中的引用。在这个目标中，引用类型将指向源对象的内存位置。|offset|length|style|BOLD|5368004|深度复制将对象的值和引用类型复制到目标对象的完整新副本中。这意味着值类型和引用类型都将被分配一个新的内存位置。|5368005|entityMap^0|0|6|3|1N|2|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

I came to understand from the following lines.

Shallow copy copies an object value type(int, float, bool) fields in to target object and object's reference types(string, class etc) are copied as references in target object. In this target reference types will be pointing to the memory location of source object.

Deep copy copies an object's value and reference types into a complete new copy of the target objects. This means both the value types and reference types will be allocated a new memory locations.

blocks|key|3111262|text|Shallow+copying是创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果字段是值类型-->，则执行字段的逐位复制；对于引用类型+-->，将复制引用，但不复制引用的对象；因此，原始对象及其克隆引用相同的对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3111263|Deep+copy是创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果一个字段是一个类型的值，输入+-->就会执行该字段的逐位复制。如果字段是引用类型+-->，则执行所引用对象的新副本。要克隆的类必须标记为Serializable。|3111264|entityMap^0|0|7|1X|4|0|0|4|1B|7|24|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

Shallow copying is creating a new object and then copying the non-static fields of the current object to the new object. If a field is a value type --> a bit-by-bit copy of the field is performed; for a reference type --> the reference is copied but the referred object is not; therefore the original object and its clone refer to the same object.

Deep copy is creating a new object and then copying the nonstatic fields of the current object to the new object. If a field is a value type --> a bit-by-bit copy of the field is performed. If a field is a reference type --> a new copy of the referred object is performed. The classes to be cloned must be flagged as [Serializable].

blocks|key|3111077|text|正在复制数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3111078|数组是一个类，这意味着它是引用类型，因此array1+=+array2会导致两个引用同一数组的变量。|3111079|但是看看这个例子：|3111080|++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]+%2B+"+"+%2B+arr2[2]);
++++++++arr2+=+arr1;
++++++++Console.WriteLine(arr1[2]+%2B+"+"+%2B+arr2[2]);+
++++++++arr2+=+(int[])arr1.Clone();
++++++++arr1[2]+=+12;
++++++++Console.WriteLine(arr1[2]+%2B+"+"+%2B+arr2[2]);
++++}|code-block|syntax|javascript|3111081|浅克隆意味着只复制克隆阵列所代表的内存。|offset|length|style|BOLD|3111082|如果数组包含值类型对象，则将值复制为；|3111083|如果数组包含引用类型，则只复制引用-因此会有两个成员引用相同对象的数组。|3111084|要创建深度复制-其中引用类型是重复的，您必须遍历数组并手动克隆每个元素。|3111085|entityMap^0|0|0|0|0|0|3|0|I|1|0|0|10|0|0|10|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@$M|13|N|14|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@$M|16|N|17|O|P]]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@$M|19|N|1A|O|P]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@$M|1C|N|1D|O|P]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

Copying ararys :

Array is a class, which means it is reference type so array1 = array2 results
in two variables that reference the same array.

But look at this example:

<pre><code> 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]);
 }
</code></pre>

shallow clone means that only the memory represented by the cloned array is copied. 

If the array contains value type objects, the values are copied; 

if the array contains reference type, only the references are copied - so as a result there are two arrays whose members reference the same objects. 

To create a deep copy—where reference type are duplicated, you must loop through the array and clone each element manually.

blocks|key|3956892|text|复制构造函数用于使用先前创建的相同类的对象初始化新对象。默认情况下，编译器编写了一个浅层副本。当不涉及动态内存分配时，浅拷贝工作得很好，因为当涉及动态内存分配时，两个对象将指向堆中的相同内存位置，因此为了消除这个问题，我们编写了深度拷贝，以便两个对象在内存中都有自己的属性副本。为了阅读包含完整示例和解释的详细信息，您可以查看文章C%2B%2B+constructors。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3956893|entityMap|0|LINK|mutability|MUTABLE|url|http://www.hellgeeks.com/constructors-and-destructors/^0|4L|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

The copy constructor is used to initialize the new object with the previously created object of the same class. By default compiler wrote a shallow copy. Shallow copy works fine when dynamic memory allocation is not involved because when dynamic memory allocation is involved then both objects will points towards the same memory location in a heap, Therefore to remove this problem we wrote deep copy so both objects have their own copy of attributes in a memory.
In order to read the details with complete examples and explanations you could see the article <a href="http://www.hellgeeks.com/constructors-and-destructors/" rel="nofollow">C++ constructors</a>.

blocks|key|3957554|text|为了混淆浅拷贝和简单地分配一个新的变量名到list，只需添加更多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3957555|“假设我们有：|3957556|x+=+[
++++[1,2,3],
++++[4,5,6],
++++]|code-block|syntax|javascript|3957557|此语句创建3个列表:2个内部列表和1个外部列表。然后，在名称x下提供对外部列表的引用。|3957558|y+=+x|3957559|不会复制任何数据。我们在内存中的某个地方仍然有相同的3个列表。所做的所有工作就是使外部列表在名称y下可用，以及它以前的名称x。|3957560|y+=+list(x)|3957561|或|3957562|y+=+x[:]|3957563|这将创建一个与x具有相同内容的新列表。列表x包含对两个内部列表的引用，因此新列表也将包含对这两个相同内部列表的引用。只复制一个列表-外部列表。现在内存中有4个列表，两个内部列表，外部列表和外部列表的副本。原来的外部列表在名称x下可用，而新的外部列表在名称y下可用。|3957564|内部列表尚未复制！此时，您可以从x或y访问和编辑内部列表！|3957565|如果您有一个二维(或更高)的列表，或者任何类型的嵌套数据结构，并且您想要对所有内容进行完整复制，那么您需要在复制模块中使用deepcopy()函数。您的解决方案也适用于2-D列表，因为迭代外部列表中的项并创建每个项目的副本，然后为所有内部副本构建一个新的外部列表。“|3957566|来源：https://www.reddit.com/r/learnpython/comments/1afldr/why_is_copying_a_list_so_damn_difficult_in_python/|offset|length|3957567|entityMap|0|LINK|mutability|MUTABLE|url|https://www.reddit.com/r/learnpython/comments/1afldr/why_is_copying_a_list_so_damn_difficult_in_python/^0|0|0|0|0|0|0|0|0|0|0|0|0|3|2V|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1O|8|@]|9|@$12|1P|13|1Q|1|1R]]|A|$]]|$1|14|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

To add just a little more for confusion between shallow copy and simply assign a new variable name to list.

"Say we have:

<pre><code>x = [
 [1,2,3],
 [4,5,6],
 ]
</code></pre>

This statement creates 3 lists: 2 inner lists and one outer list. A reference to the outer list is then made available under the name x. If we do

<pre><code>y = x
</code></pre>

no data gets copied. We still have the same 3 lists in memory somewhere. All this did is make the outer list available under the name y, in addition to its previous name x. If we do

<pre><code>y = list(x)
</code></pre>

or

<pre><code>y = x[:]
</code></pre>

This creates a new list with the same contents as x. List x contained a reference to the 2 inner lists, so the new list will also contain a reference to those same 2 inner lists. Only one list is copied—the outer list.
Now there are 4 lists in memory, the two inner lists, the outer list, and the copy of the outer list. The original outer list is available under the name x, and the new outer list is made available under the name y.

The inner lists have not been copied! You can access and edit the inner lists from either x or y at this point!

If you have a two dimensional (or higher) list, or any kind of nested data structure, and you want to make a full copy of everything, then you want to use the deepcopy() function in the copy module. Your solution also works for 2-D lists, as iterates over the items in the outer list and makes a copy of each of them, then builds a new outer list for all the inner copies."

source: <a href="https://www.reddit.com/r/learnpython/comments/1afldr/why_is_copying_a_list_so_damn_difficult_in_python/" rel="nofollow noreferrer">https://www.reddit.com/r/learnpython/comments/1afldr/why_is_copying_a_list_so_damn_difficult_in_python/</a>

blocks|key|3111331|text|除了上面的所有定义之外，还有一个最常用的深度副本，位于该类的复制构造函数(或重载赋值运算符)中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3111332|浅层复制-->是指不提供复制构造函数的情况。在这里，只有对象被复制，但不是类的所有成员都被复制。|3111333|Deep+copy+-->是当您决定在类中实现复制构造函数或重载赋值，并允许复制类的所有成员时。|3111334|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
}|code-block|syntax|javascript|3111335|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Adding to all the above definitions, one more and most commonly used deep copy, is in the copy constructor (or overloading assignment oprator) of the class.

Shallow copy --> is when you are not providing copy constructor. Here, only the object gets copied but not all the members of the class are copied.

Deep copy --> is when you have decided to implement copy constructor or overload assignment in your class and allows copying all the members of the class.

<pre><code>MyClass&amp; MyClass(const MyClass&amp; obj) // copy constructor for MyClass
{
 // write your code, to copy all the members and return the new object
}
MyClass&amp; operator=(const MyClass&amp; obj) // overloading assignment operator,
{
 // write your code, to copy all the members and return the new object
}
</code></pre>

What is the difference between a deep copy and a shallow copy?

What is the difference between a deep copy and a shallow copy?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

问深拷贝和浅拷贝有什么区别？
EN

回答 31

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问深拷贝和浅拷贝有什么区别？EN

回答 31

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问深拷贝和浅拷贝有什么区别？
EN