对深拷贝和浅拷贝的个人理解

雨点打透心脏的1/2处 2022-08-25 11:55 234阅读 0赞

1.深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是**Value****（值）对象的深拷贝且只能进行深拷贝**，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。

考虑以下写法

int  source =  int .MaxValue; //(1) 初始化源对象为整数的最大值 2,147,483,647

int  dest = source; //(2) 赋值，内部执行深拷贝

dest = 1024; //(3) 对拷贝对象进行赋值

source = 2048; //(4) 对源对象进行赋值

首先（ 2 ）中将 source 赋给 dest ，执行了深拷贝动作，其时 dest 和 source 的值是一样的，都是 int.MaxValue ；（ 3 ）对 dest 进行修改， dest 值变为 1024 ，由于是深拷贝，因此不会运行 source ， source 仍然是 int.MaxValue ；（ 4 ）对 source 进行了修改，同样道理， dest 仍然是 1024 ，同时 int.MaxValue 的值也不变，仍然是 2,147,483,647 ；只有 source 变成了 2048 。

再考虑以下写法

struct Point

public int  X;

public int  Y;

public  Point( int  x,  int  y)

X = x;

Y = y;

Point  source =  new Point (10, 20);

Point  dest = source;

dest.X = 20

当 dest.X 属性变成 20 后， source 的 X 属性仍然是 10

2.          浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。比较典型的就有 Reference （引用）对象的浅拷贝，如 Class （类）。

考虑以下写法

class Point

public int  X;

public int  Y;

public  Point( int  x,  int  y)

X = x;

Y = y;

Point  source =  new Point (10, 20);

Point  dest = source;

dest.X = 20;

由于 Point 现在是引用对象，因此 Point dest=source 的赋值动作实际上执行的是浅拷贝，最后的结果应该是 source 的 X 字段值也变成了 20 。即它们引用了同一个对象，仅仅是变量明 source 和 dest 不同而已。

3.          引用对象的浅拷贝原理

引用对象之间的赋值之所以执行的是浅拷贝动作，与引用对象的特性有关，一个引用对象一般来说由两个部分组成

（ 1 ）一个具名的 Handle ，也就是我们所说的声明（如变量）

（ 2 ）一个内部（不具名）的对象，也就是具名 Handle 的内部对象。它在 Manged Heap （托管堆）中给对象分配空间，一般由新增引用对象的 New 方法是进行创建。

如果这个内部对象已被创建，那么具名的 Handle 就指向这个内部对象在 Manged Heap 中的地址，否则就是 null （从某个方面来讲，如果这个具名的 handle 可以被赋值为 null ，说明这是一个引用对象，当然不是绝对）。两个引用对象如果进行赋值，它们仅仅是复制这个内部对象的地址，内部对象仍然是同一个，因此，源对象或拷贝对象的修改都会影响对方。这也就是浅拷贝

4.          引用对象如何进行深拷贝

由于引用对象的赋值仅仅是复制具名 Handle （变量）指向的地址，因此要对引用对象进行深拷贝就要重新创建一份该对象的实例，并对该对象的字段进行逐一赋值，如以下写法

class Point

public int  X;

public int  Y;

public  Point( int  x,  int  y)

X = x;

Y = y;

Point  source =  new Point (10, 20);

Point  dest =  new Point (source.X, source.Y);

// 或以下写法

//Point dest = new Point()

//dest.X = source.X

//dest.Y = source.Y

其时， source 和 dest 就是两个互相独立的对象了，两者的修改都不会影响对方。 ***但我个人认为这个例子并不算是真正意义上的引用对象的深拷贝，他们之间实际上进行的是 值类型的深拷贝。也不知道我的见解是不是对的，请大家研判。***

5 ．一些需要注意的东西

（ 1 ）： String 字符串对象是引用对象，但是很特殊，它表现的如值对象一样，即对它进行赋值，分割，合并，并不是对原有的字符串进行操作，而是返回一个新的字符串对象

（ 2 ）： Array 数组对象是引用对象，在进行赋值的时候，实际上返回的是源对象的另一份引用而已；因此如果要对数组对象进行真正的复制（深拷贝），那么需要新建一份数组对象，然后将源数组的值逐一拷贝到目的对象中。

Array数组对象以线性组合数组元素。数组元素可以使值类型或是引用对象。当数组元素是值类型时：

Int\[\] i = new int\[2\];

new为数组分配空间， 初始值为int 的初始默认值：i\[0\]  = 0， i\[ 1\] = 0。

党数组元素是引用类型时：

T\[\] t = new T\[2\];

初始值为T t 的初始默认值: t\[0\] = null, t\[1\] = null.

此后，为了初始化数组元素(元素是引用变量)，可以用 new 操作符创建对象：

t\[0\] = new T();

t\[1\] = new T();

我认为i数组对象的引用特性决定了它的对象的Clone and CopyTo method 只能执行shallow 即浅拷贝。 因为无论是

*  T\[\] ts = new T\[2\]; ts = t;实际上是把t的对象的引用给ts.
 *  ts\[i\] = t\[i\]; 把t\[i\]的引用复制一个给ts\[i\].
 *  T ts = new T(); T t = new T(); t.x = 4; ts = t; 实际上是把t的引用给ts.

因此，如果想要执行数组的深拷贝。须使T类实现 ICloneable Interface 的 public object Clone() 方法. 实例如下：

class cck  
    \{  
        public class Person : ICloneable  
        \{  
            public int age;

public object Clone()  
            \{  
                Person sp = new Person();  
                sp.age = this.age;  
                return sp;  
            \}  
            public void Show()  
            \{  
                Console.WriteLine("age：\{0\}", age);  
            \}

public static void ShowPersons(Person\[\] persons)  
        \{  
            for (int i = 0; i < persons.GetLength(0); i++)  
            \{  
                persons\[i\].Show();  
            \}  
        \}

static void Main(string\[\] args)  
        \{

\#region 执行深拷贝  
            Person pson = new Person();  
            pson.age = 14;  
            pson.Show();  
            Person pson1 = (Person)pson.Clone();  
            pson1.age = 16;  
            pson1.Show();  
            pson.Show();

\#endregion

\#region 浅拷贝

Person pson = new Person();  
            pson.age = 14;  
            pson.Show();  
            Person pson1 = (Person)pson.Clone();  
            pson1.age = 16;  
            pson1.Show();  
            pson.Show();

\#endregion

Random rnd = new Random(unchecked((int)DateTime.Now.Ticks));  
            Person\[\] persons = new Person\[4\];  
            for (int i = 0; i < persons.GetLength(0); i++)  
            \{  
                persons\[i\] = new Person();  
                persons\[i\].age = rnd.Next() % 50;  
            \}  
            //打印原始数组  
            Console.WriteLine("打印原始数组");  
            ShowPersons(persons);  
            //深拷贝  
            //声明新的object 和 内存地址。  
            Person\[\] personsCopied = new Person\[4\];  
            for (int i = 0; i < personsCopied.GetLength(0); i++)  
            \{  
                //在Clone中创建新的Person对象并把他创建的新的内存地址

//reference 到新的object上。  
                personsCopied\[i\] = (Person)persons\[i\].Clone();  
            \}  
             
            Console.WriteLine("深拷贝的数组");  
            ShowPersons(personsCopied);  
            //      //浅拷贝  
            //把每个persons的element的reference copy 给personsCopied。  
            //persons.CopyTo(personsCopied, 0);  
            //or Array 的Clone 是 shallow 拷贝  
            //只声明了object 没有内存地址， person 数组把original 的reference复制一份给personsCloned.  
           //      Person\[\] personsCloned = (Person\[\])persons.Clone();  
            //      Console.WriteLine("浅拷贝的数组");  
            //      ShowPersons(personsCloned);  
            //对原数组做修改  
            persons\[2\].age += 10;  
            Console.WriteLine("打印修改后的原始数组");  
            ShowPersons(persons);  
            Console.WriteLine("深拷贝的数组应该不改变");  
            ShowPersons(personsCopied);  
            //      Console.WriteLine("浅拷贝的数组应该改变");  
            //      ShowPersons(personsCloned);

\}  
    \}

![123.gif][]

另外注意 persons.CopyTo(personsCopied, 0); 这一句并不是对personsCopied进行深表复制，数组直接拷贝是拷贝的指向同一个对象的引用，因为在C＃中对于存放引用类型的数组，数组本身的引用类型和数组中元素的引用类型不能混为一谈，此时的数组仅相当于一个容器，所以对于容器本身和容器中存放的东西是要分别进行实例化的。

Q: SqlConnection con = new SqlConnection();  
SqlConnection c = con;  
c = null;  
为什么执行上面语句后con对象没有为null呢?

A: con 是一个引用对象 , 因此有两个部分 handle 和对象 , 将设 con 所持有的 handle 叫 HandleA.接下来当声明了sqlconnection c时,c具有另外的一个handle,假设叫HandleB.将con赋给c后,只是HandleB也指向HandleA所指向的对象.即内部对象一样,但是指向对象的Handle不一样了.当执行c=null时,仅仅是将HandleB指向了null.原先指向的对象仍然不变,所以con对象不为null

Class 的 默认方法是MemberwiseClone 执行的是 浅拷贝。 需要在类中实现ICloneable clone方法来实现. MemberwiseClone 是个protected 方法。 ArrayClone方法其实上调用的MemberwiseClone方法,执行的是浅拷贝。

[123.gif]: /images/20220824/c18b38c60e164ed784cd3562d9721898.png