由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