除了上述所有定义之外，还有一个最常用的深度复制，位于类的复制构造函数(或重载赋值操作符)中。

浅复制——>是当你没有提供复制构造函数时。在这里，只复制对象，但不复制类的所有成员。

深度复制——>是当您决定在类中实现复制构造函数或重载赋值，并允许复制类的所有成员时。

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
}

char * Source = "Hello, world.";

char * ShallowCopy = Source;    

char * DeepCopy = new char(strlen(Source)+1);
strcpy(DeepCopy,Source);        

“ShallowCopy”指向与“Source”相同的内存位置。 “DeepCopy”指向内存中的不同位置，但内容是相同的。

复制array:

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

浅克隆意味着只复制克隆数组所表示的内存。

如果数组包含值类型对象，则复制值;

如果数组包含引用类型，则只复制引用-因此有两个数组，其成员引用相同的对象。

要创建复制引用类型的深度复制，必须循环遍历数组并手动克隆每个元素。

浅拷贝构造一个新的复合对象，并将其对原始对象的引用插入其中。

与浅拷贝不同，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在这里所做的是，它将创建一个新的复合对象，但其中的对象指向原始对象。

在图像中，它为外层列表创建了一个新的副本。但内部列表与原始列表保持一致。

现在我们使用z = copy.deepcopy(x)创建它的深度复制。python在这里所做的是，它将为外部列表和内部列表创建新对象。如下图所示(红色高亮部分)。

最后代码输出False，因为y和z不是相同的对象。

HTH.

浅复制是创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果字段是值类型——>，则执行字段的逐位复制;对于引用类型——>，引用被复制，但被引用的对象没有;因此，原始对象及其克隆对象引用同一个对象。

深度复制是创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果字段是值类型——>，则执行字段的逐位复制。如果字段是引用类型——>，则执行引用对象的新副本。要克隆的类必须标记为[Serializable]。

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 C++ constructors.