由struct 和class 想到的淺度復制和深度復制 c#

 

記得c++里面，struct 和class 的唯一不同點是，class的成員默認是private，struct的則默認是public。

在c#里則不然，struct 默認仍然是private。所以，不禁要問，struct和class有什么區別呢？

struct 是值類型的，而calss是引用類型的。

舉個例子，

struct Mystruct
{
    public int x;
}

class Myclass
{
    public int x;
}

如果執行以下代碼，

Mystruct st1 = new Mystruct();
st1.x = 1;
Mystruct st2 = st1;
st2.x = 2;

Myclass cs1 = new Myclass();
cs1.x = 1;
Myclass cs2 = cs1;
cs2.x = 2;

那么修改st2不會影響st1，但是修改cs2則同時也修改了cs1. 這就是值類型和引用類型的區別。cs1 和cs2只是一個指針，他們指向同一個地址。所以修改其中任何一個，他們都會同時被修改。

既然有值類型和引用類型之分，我們看一看下面這個初學者容易出錯的例子：

Myclass [] array = new Myclass[5];

Myclass tmp = new Myclass();

for (int i=0;i<5;i++)

{

    tmp.x = i;

    array[i] = tmp;

}

array是不是一個x值等於下標的一個類數組呢？答案是否定的，array數組里面，所有的x都等於4.

於是對於類復制，引發了有淺度復制和深度復制等概念。

淺度復制是用過派生於System.Object 的MemberwiseClone()實現的，它可以復制所有值類型，但是對於引用類型，還是只復制了指針。

深度復制需要實現ICloneable借口的Clone()函數，實現引用類型的復制。

看一個例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleTest
{
    class Program
    {
        static void Main(string[] args)
        {
            CloneExample a = new CloneExample();
            a.content = new Content() { con = 1 };
            a.x = 2;

            // 淺度復制
            CloneExample b = (CloneExample) a.ShallowCopy();
            b.content.con = 11;
            b.x = 22;
            Console.WriteLine("a.content.con = {0}",a.content.con); 
            Console.WriteLine("a.x = {0}", a.x);

            //再試一試深度復制
            a.content.con = 1;
            b = (CloneExample)a.Clone();
            b.content.con = 11;
            b.x = 22;
            Console.WriteLine("a.content.con = {0}", a.content.con);//淺度復制和深度復制的區別體現在，引用類型會不會受影響
            Console.WriteLine("a.x = {0}", a.x);



            Console.ReadKey();
        }


    }

    class Content {
        public int con;
    }

    class CloneExample:ICloneable
    {
        public int x;
        public Content content;

        public object ShallowCopy()
        {
            return this.MemberwiseClone();
        }

        public object Clone()
        {
            CloneExample instance = new CloneExample();
            instance.x = this.x;
            instance.content = new Content() { con = this.content.con };
            return instance;
        }
    }
}

使用深度復制，新的變量和就的變量是獨立的，互不影響。

運行結果：

a.content.con = 11
a.x = 2
a.content.con = 1
a.x = 2