也来谈一谈js的浅复制和深复制-爱编程
也来谈一谈js的浅复制和深复制
1.浅复制VS深复制
本文中的复制也可以称为拷贝，在本文中认为复制和拷贝是相同的意思。另外，本文只讨论js中复杂数据类型的复制问题（Object,Array等），不讨论基本数据类型（null,undefined,string,number和boolean），这些类型的值本身就存储在栈内存中(string类型的实际值还是存储在堆内存中的，但是js把string当做基本类型来处理&)，不存在引用值的情况。
浅复制和深复制都可以实现在已有对象的基础上再生一份的作用，但是对象的实例是存储在堆内存中然后通过一个引用值去操作对象，由此复制的时候就存在两种情况了：复制引用和复制实例，这也是浅复制和深复制的区别所在。
浅复制：浅复制是复制引用，复制后的引用都是指向同一个对象的实例，彼此之间的操作会互相影响
深复制：深复制不是简单的复制引用，而是在堆中重新分配内存，并且把源对象实例的所有属性都进行新建复制，以保证深复制的对象的引用图不包含任何原有对象或对象图上的任何对象，复制后的对象与原来的对象是完全隔离的
由深复制的定义来看，深复制要求如果源对象存在对象属性，那么需要进行递归复制，从而保证复制的对象与源对象完全隔离。然而还有一种可以说处在浅复制和深复制的粒度之间，也是jQuery的extend方法在deep参数为false时所谓的&浅复制&，这种复制只进行一个层级的复制：即如果源对象中存在对象属性，那么复制的对象上也会引用相同的对象。这不符合深复制的要求，但又比简单的复制引用的复制粒度有了加深。
本文认为浅复制就是简单的引用复制，这种情况较很简单，通过如下代码简单理解一下：
var src = {
name:"src"
//复制一份src对象的应用
var target =
target.name = "target";
console.log(src.name);
//输出target
target对象只是src对象的引用值的复制，因此target的改变也会影响src。
深复制的情况比较复杂一些，我们先从一些比较简单的情况说起：
3.1 Array的slice和concat方法
Array的slice和concat方法都会返回一个新的数组实例，但是这两个方法对于数组中的对象元素却没有执行深复制，而只是复制了引用了，因此这两个方法并不是真正的深复制，通过以下代码进行理解：
var array = [1,2,3];
var array_shallow =
var array_concat = array.concat();
var array_slice = array.slice(0);
console.log(array === array_shallow);
console.log(array === array_slice);
console.log(array === array_concat);
可以看出，concat和slice返回的不同的数组实例，这与直接的引用复制是不同的。
var array = [1, [1,2,3], {name:"array"}];
var array_concat = array.concat();
var array_slice = array.slice(0);
//改变array_concat中数组元素的值
array_concat[1][0] = 5;
console.log(array[1]);
console.log(array_slice[1]);
//改变array_slice中对象元素的值
array_slice[2].name = "array_slice";
console.log(array[2].name);
//array_slice
console.log(array_concat[2].name); //array_slice
通过代码的输出可以看出concat和slice并不是真正的深复制，数组中的对象元素(Object,Array等)只是复制了引用
3.2 JSON对象的parse和stringify
JSON对象是ES5中引入的新的类型（支持的浏览器为IE8+），JSON对象parse方法可以将JSON字符串反序列化成JS对象，stringify方法可以将JS对象序列化成JSON字符串，借助这两个方法，也可以实现对象的深复制。
var source = {
name:"source",
name:"child"
var target = JSON.parse(JSON.stringify(source));
//改变target的name属性
target.name = "target";
console.log(source.name);
console.log(target.name);
//改变target的child
target.child.name = "target child";
console.log(source.child.name);
console.log(target.child.name);
//target child
从代码的输出可以看出，复制后的target与source是完全隔离的，二者不会相互影响。
这个方法使用较为简单，可以满足基本的深复制需求，而且能够处理JSON格式能表示的所有数据类型，但是对于正则表达式类型、函数类型等无法进行深复制(而且会直接丢失相应的值)，同时如果对象中存在循环引用的情况也无法正确处理
3.3 jQuery中的extend复制方法
jQuery中的extend方法可以用来扩展对象，这个方法可以传入一个参数:deep(true or false)，表示是否执行深复制(如果是深复制则会执行递归复制)，我们首先看一下jquery中的源码(1.9.1)
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[0] || {},
length = arguments.length,
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
target = arguments[1] || {};
// skip the boolean and the target
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
// extend jQuery itself if only one argument is passed
if ( length === i ) {
for ( ; i & i++ ) {
// Only deal with non-null/undefined values
if ( (options = arguments[ i ]) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
// Prevent never-ending loop
if ( target === copy ) {
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
if ( copyIsArray ) {
copyIsArray =
clone = src && jQuery.isArray(src) ? src : [];
clone = src && jQuery.isPlainObject(src) ? src : {};
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] =
// Return the modified object
这个方法是jQuery中重要的基础方法之一，可以用来扩展jQuery对象及其原型，也是我们编写jQuery插件的关键方法，事实上这个方法基本的思路就是如果碰到array或者object的属性，那么就执行递归复制，这也导致对于Date,Function等引用类型，jQuery的extend也无法支持。下面我们大致分析一下这个方法：
（1）第1-6行定义了一些局部变量，这些局部变量将在以后用到，这种将函数中可能用到的局部变量先统一定义好的方式也就是&单var&模式
（2）第9-13行用来修正deep参数，jQuery的这个方法是将deep作为第一个参数传递的，因此这里就判断了第一个参数是不是boolean类型，如果是，那么就调整target和i值，i值表示第一个source对象的索引
（3）第17-19行修正了target对象，如果target的typeof操作符返回的不是对象，也不是函数，那么说明target传入的是一个基本类型，因此需要修正为一个空的对象字面量{}
（4）第22-25行来处理只传入了一个参数的情况，这个方法在传入一个参数的情况下为扩展jQuery对象或者其原型对象
（5）从27行开始使用for in去遍历source对象列表，因为extend方法是可以传入多个source对象，取出每一个source对象，然后再嵌套一个for in循环，去遍历某个source对象的属性
（6）第32行分别取出了target的当前属性和source的当前属性，35-38行的主要作用在于防止深度遍历时的死循环。然而如果source对象本身存在循环引用的话，extend方法依然会报堆栈溢出的错误
（7）第41行的if用来处理深复制的情况，如果传入的deep参数为true，并且当前的source属性值是plainObject(使用对象字面量创建的对象或new Object()创建的对象)或数组，则需要进行递归深复制
（8）第42-48根据copy的类型是plainObject还是Array，对src进行处理：如果copy是数组，那么src如果不是数组，就改写为一个空数组；如果copy是chainObject，那么src如果不是chainObject，就改写为{}
（9）如果41行的if条件不成立，那么直接把target的src属性用copy覆盖
jQuery的extend方法使用基本的递归思路实现了深度复制，但是这个方法也无法处理source对象内部循环引用的问题，同时对于Date、Function等类型的值也没有实现真正的深度复制，但是这些类型的值在重新定义时一般都是直接覆盖，所以也不会对源对象造成影响，因此一定程度上也符合深复制的条件
3.4 自己实现一个copy方法
根据以上的思路，自己实现一个copy，可以传入deep参数表示是否执行深复制：
//util作为判断变量具体类型的辅助模块
var util = (function(){
var class2type = {};
["Null","Undefined","Number","Boolean","String","Object","Function","Array","RegExp","Date"].forEach(function(item){
class2type["[object "+ item + "]"] = item.toLowerCase();
function isType(obj, type){
return getType(obj) ===
function getType(obj){
return class2type[Object.prototype.toString.call(obj)] || "object";
isType:isType,
getType:getType
function copy(obj,deep){
//如果obj不是对象，那么直接返回值就可以了
if(obj === null || typeof obj !== "object"){
　　　　　//定义需要的局部变脸，根据obj的类型来调整target的类型
var i, target = util.isType(obj,"array") ? [] : {},value,valueT
for(i in obj){
value = obj[i];
valueType = util.getType(value);
　　　　　　　　//只有在明确执行深复制，并且当前的value是数组或对象的情况下才执行递归复制
if(deep && (valueType === "array" || valueType === "object")){
target[i] = copy(value);
target[i] =
版权所有 爱编程 (C) Copyright 2012. . All Rights Reserved.
闽ICP备号-3
微信扫一扫关注爱编程，每天为您推送一篇经典技术文章。了解深复制和浅复制
原型模式中也会涉及到这个概念，在这里先深入了解一下，
C# 支持两种类型：“值类型”和“引用类型”。
值类型（Value Type)（如 char、int 和 float）、枚举类型和结构类型。
引用类型(Reference Type) 包括类 (Class) 类型、接口类型、委托类型和数组类型。
如何来划分它们？
以它们在计算机内存中如何分配来划分
值类型与引用类型的区别?
1,值类型的变量直接包含其数据，
2,引用类型的变量则存储对象引用。
对于引用类型，两个变量可能引用同一个对象，因此对一个变量的操作可能影响另一个变量所引用的对象。对于值类型，每个变量都有自己的数据副本，对一个变量的操作不可能影响另一个变量。
值类型隐式继承自System.ValueType&
所以不能显示让一个结构继承一个类，C#不支持多继承
堆栈(stack)是一种先进先出的数据结构，在内存中，变量会被分配在堆栈上来进行操作。
堆(heap)是用于为类型实例(对象)分配空间的内存区域，在堆上创建一个对象，
会将对象的地址传给堆栈上的变量(反过来叫变量指向此对象，或者变量引用此对象)。
关于对象克隆的所设计到知识点
浅拷贝：是指将对象中的所有字段逐字复杂到一个新对象
对值类型字段只是简单的拷贝一个副本到目标对象，改变目标对象中值类型字段的值不会反映到原始对象中，因为拷贝的是副本
对引用型字段则是指拷贝他的一个引用到目标对象。改变目标对象中引用类型字段的值它将反映到原始对象中，因为拷贝的是指向堆是上的一个地址
深拷贝：深拷贝与浅拷贝不同的是对于引用字段的处理，深拷贝将会在新对象中创建一个新的对象和
原始对象中对应字段相同（内容相同）的字段，也就是说这个引用和原始对象的引用是不同， 我们改变新
对象中这个字段的时候是不会影响到原始对象中对应字段的内容。
浅复制： 实现浅复制需要使用Object类的MemberwiseClone方法用于创建一个浅表副本
深复制： 须实现 ICloneable接口中的Clone方法，且需要需要克隆的对象加上[Serializable]特性
********CODE***********
public Car(string name)
&&&&&&&&&&&
this.name =
public int[] arr = new int[1];
public Person(int id, string name, Car car)
&&&&&&&&&&&
&&&&&&&&&&&
this.name =
&&&&&&&&&&&
this.car =
public void setArr(int str)
&&&&&&&&&&&
public Object Clone()　　//对外提供一个创建自身的浅表副本的能力
&&&&&&&&&&&
return this.MemberwiseClone();
************Main函数中执行的Code***********
&Person p1 = new Person(1, "Scott", new
Car("宝马"));
&&&&&&&&&&&
p1.setArr(1);
&&&&&&&&&&&
Person p2 = (Person)p1.Clone();　//克隆一个对象
&&&&&&&&&&&
Console.WriteLine("改变P1的值");
&&&&&&&&&&&
p1.id = 2;
&&&&&&&&&&&
p1.name = "Lacy";
&&&&&&&&&&&
p1.car.name = "红旗";
&&&&&&&&&&&
p1.setArr(3);
&&&&&&&&&&&
Console.WriteLine("P1:id={0}-----------&name={1}------&car={2}--&ARR:{3}",
p1.id, p1.name, p1.car.name, p1.arr[0]);
&&&&&&&&&&&
Console.WriteLine("P2:id={0}-----------&name={1}------&car={2}--&ARR:{3}",
p2.id, p2.name, p2.car.name, p2.arr[0]);
&&&&&&&&&&&
Console.Read();
**********输出结果result***********
**************分析******************
Person类中采用的是浅复制MemberwiseClone()，虽然string是引用类型，但由于它的特殊性参考string特殊类型的文章解析，可以看到数组和car类由于都是引用类型，改变p1对象的内容时，p2也进行了改变，因为浅复制只是拷贝引用类型的地址。
****************实现深拷贝************
&[Serializable]
public Car(string name)
&&&&&&&&&&&
this.name =
[Serializable]
Person: ICloneable
public int[] arr = new int[1];
public Person(int id, string name, Car car)
&&&&&&&&&&&
&&&&&&&&&&&
this.name =
&&&&&&&&&&&
this.car =
public void setArr(int str)
&&&&&&&&&&&
public Object Clone()　　//clone方法
&&&&&&&&&&&
//return this.MemberwiseClone();
&&&&&&&&&&&
//创建内存流&&&&
&&&&&&&&&&&
MemoryStream ms = new MemoryStream();
&&&&&&&&&&&
//以二进制格式进行序列化&&&&&&&&&
&&&&&&&&&&&
BinaryFormatter bf = new BinaryFormatter();
&&&&&&&&&&&
bf.Serialize(ms, this);
&&&&&&&&&&&
//反序列化当前实例到一个object&&&
&&&&&&&&&&&
ms.Seek(0, 0);
&&&&&&&&&&&
object obj = bf.Deserialize(ms);
&&&&&&&&&&&
//关闭内存流&&&&&&&&&&&
&&&&&&&&&&&
ms.Close();
&&&&&&&&&&&
//main函数中执行与上浅拷贝中相同的逻辑代码
****************输出结果result***************
***************分析*******************
执行深复制，注意给类上添加[Serializable]序列化标签，继承ICloneable接口，自定义实现Clone（）方法，通过序列化实现深复制。
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。随笔 - 163&
文章 - 1&评论 - 18&trackbacks - 0
from： http://blog.csdn.net/lai123wei/article/details/7217365&&1.深拷贝与浅拷贝 &
拷贝即是通常所说的复制(Copy)或克隆(Clone)，对象的拷贝也就是从现有对象复制一个“一模一样”的新对象出来。虽然都是复制对象，但是不同的 复制方法，复制出来的新对象却并非完全一模一样，对象内部存在着一些差异。通常的拷贝方法有两种，即深拷贝和浅拷贝，那二者之间有何区别呢？MSDN里对
IClone接口的Clone方法有这样的说明：在深层副本中，所有的对象都是重复的；而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引 用。可以看出，深拷贝和浅拷贝之间的区别在于是否复制了子对象。这如何理解呢？下面我通过带有子对象的代码来验证二者的区别。 首先定义两个类型：Student和ClassRoom，其中Student类型里包含ClassRoom，并使这两个类型都分别实现自定义的深拷贝接口(IDeepCopy)和浅拷贝接口(IShallowCopy)。 类图如下：
定义代码如下：&View Code ///&&summary&&&&&///&深拷贝接口&&&&///&&/summary&&&&&interface&IDeepCopy&&&&{&&&&&&&&object&DeepCopy();&&&&}&&&&///&&summary&&&&&///&浅拷贝接口&&&&///&&/summary&&&&&interface&IShallowCopy&&&&{&&&&&&&&object&ShallowCopy();&&&&}&&&&///&&summary&&&&&///&教室信息&&&&///&&/summary&&&&&class&ClassRoom&:&IDeepCopy,&IShallowCopy&&&&{&&&&&&&&public&int&RoomID&=&1;&&&&&&&&public&string&RoomName&=&"Room1";&&&&&&&&public&override&string&ToString()&&&&&&&&{&&&&&&&&&&&&return&"RoomID="&+&RoomID&+&"\tRoomName="&+&RoomN&&&&&&&&}&&&&&&&&public&object&DeepCopy()&&&&&&&&{&&&&&&&&&&&&ClassRoom&r&=&new&ClassRoom();&&&&&&&&&&&&r.RoomID&=&this.RoomID;&&&&&&&&&&&&r.RoomName&=&this.RoomN&&&&&&&&&&&&return&r;&&&&&&&&}&&&&&&&&public&object&ShallowCopy()&&&&&&&&{&&&&&&&&&&&&//直接使用内置的浅拷贝方法返回&&&&&&&&&&&&return&this.MemberwiseClone();&&&&&&&&}&&&&}&&&&class&Student&:&IDeepCopy,&IShallowCopy&&&&{&&&&&&&&//为了简化，使用public&字段&&&&&&&&public&string&N&&&&&&&&public&int&A&&&&&&&&//自定义类型，假设每个Student只拥有一个ClassRoom&&&&&&&&public&ClassRoom&Room&=&new&ClassRoom();&&&&&&&&public&Student()&&&&&&&&{&&&&&&&&}&&&&&&&&public&Student(string&name,&int&age)&&&&&&&&{&&&&&&&&&&&&this.Name&=&&&&&&&&&&&&&this.Age&=&&&&&&&&&}&&&&&&&&public&object&DeepCopy()&&&&&&&&{&&&&&&&&&&&&Student&s&=&new&Student();&&&&&&&&&&&&s.Name&=&this.N&&&&&&&&&&&&s.Age&=&this.A&&&&&&&&&&&&s.Room&=&(ClassRoom)this.Room.DeepCopy();&&&&&&&&&&&&return&s;&&&&&&&&}&&&&&&&&public&object&ShallowCopy()&&&&&&&&{&&&&&&&&&&&&return&this.MemberwiseClone();&&&&&&&&}&&&&&&&&public&override&string&ToString()&&&&&&&&{&&&&&&&&&&&&return&"Name:"&+&Name&+&"\tAge:"&+&Age&+&"\t"&+&Room.ToString();&&&&&&&&}&&&&}pastingpasting测试代码：&View Code Student&s1&=&new&Student("Vivi",&28);&Console.WriteLine("s1=["&+&s1&+&"]");&Student&s2&=&(Student)s1.ShallowCopy();&//Student&s2&=&(Student)s1.DeepCopy();&Console.WriteLine("s2=["&+&s2&+&"]");&//此处s2和s1内容相同&Console.WriteLine("-----------------------------");&//修改s2的内容&s2.Name&=&"tianyue";&s2.Age&=&25;&s2.Room.RoomID&=&2;&s2.Room.RoomName&=&"Room2";&Console.WriteLine("s1=["&+&s1&+&"]");&Console.WriteLine("s2=["&+&s2&+&"]");&//再次打印两个对象以比较&Console.ReadLine();&运行结果： a.ShallowCopy s1=[Name:Vivi&& Age:28& RoomID=1&&&&&&& RoomName=Room1] s2=[Name:Vivi&& Age:28& RoomID=1&&&&&&& RoomName=Room1] ------------------------------------------------------------- s1=[Name:Vivi&& Age:28& RoomID=2&&&&&&& RoomName=Room2] s2=[Name:tianyue&&&&&&& Age:25& RoomID=2&&&&&&& RoomName=Room2]
b.DeepCopy s1=[Name:Vivi&& Age:28& RoomID=1&&&&&&& RoomName=Room1] s2=[Name:Vivi&& Age:28& RoomID=1&&&&&&& RoomName=Room1] ----------------------------- s1=[Name:Vivi&& Age:28& RoomID=1&&&&&&& RoomName=Room1] s2=[Name:tianyue&&&&&&& Age:25& RoomID=2&&&&&&& RoomName=Room2] 从以上结果可以看出，深拷贝时两个对象是完全“分离”的，改变其中一个，不会影响到另一个对象； 浅拷贝时两个对象并未完全“分离”，改变顶级对象的内容，不会对另一个对象产生影响，但改变子对象的内容，则两个对象同时被改变。 这种差异的产生，即是取决于拷贝子对象时复制内存还是复制指针。深拷贝为子对象重新分配了一段内存空间，并复制其中的内容； 浅拷贝仅仅将指针指向原来的子对象。 示意图如下：
2.浅拷贝与赋值操作 大多数面向对象语言中的赋值操作都是传递引用，即改变对象的指针地址，而并没有复制内存，也没有做任何复制操作。 由此可知，浅拷贝与赋值操作的区别是顶级对象的复制与否。当然，也有一些例外情况，比如类型定义中重载赋值操作符（assignment operator）， 或者某些类型约定按值传递，就像C＃中的结构体和枚举类型。 赋值操作示意图如下：
3.C++拷贝构造函数 与其它面向对象语言不同，C++允许用户选择自定义对象的传递方式：值传递和引用传递。在值传递时就要使用对象拷贝，比如说按值传递参数，编译 器需要拷贝一个对象以避免原对象在函数体内被破坏。为此，C++提供了拷贝构造函数用来实现这种拷贝行为，拷贝构造函数是一种特殊的构造函数，用来完成一 些基于同一类的其它对象的构造和初始化。它唯一的参数是引用类型的，而且不可改变，通常的定义为X(const
X&)。在拷贝构造函数里，用户可以定义对象的拷贝行为是深拷贝还是浅拷贝，如果用户没有实现自己的拷贝构造函数，那么编译器会提供一个默认实 现，该实现使用的是按位拷贝(bitwise
copy)，也即本文所说的浅拷贝。构造函数何时被调用呢？通常以下三种情况需要拷贝对象，此时拷贝构造函数将会被调用。 1.一个对象以值传递的方式传入函数体 2.一个对象以值传递的方式从函数返回 3.一个对象需要通过另外一个对象进行初始化 4.C# MemberwiseClone与ICloneable接口 和C++里的拷贝构造函数一样，C#也为每个对象提供了浅拷贝的默认实现，不过C#里没有拷贝构造函数，而是通过顶级类型Object里的
MemberwiseClone方法。MemberwiseClone
方法创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。有没有默认的深拷贝实现呢？当然是没有，因为需要所有参与拷贝 的对象定义自己的深拷贝行为。C++里需要用户实现拷贝构造函数，重写默认的浅拷贝；C#则不同，C#(确切的说是.NET
Framework，而非C#语言)提供了ICloneable
接口，包含一个成员 Clone，它用于支持除 MemberwiseClone
所提供的克隆之外的克隆。C++通过拷贝构造函数无法确定子对象实现的是深拷贝还是浅拷贝，而C#在“强制”实现浅拷贝的基础上，提供
ICloneable 接口由用户定义深拷贝行为，通过接口来强制约束所有参与拷贝的对象，个人觉得，这也算是一小点C#对C++的改进。 & 5.深拷贝策略与实现 深拷贝的要点就是确保所有参与拷贝的对象都要提供自己的深拷贝实现，不管是C++拷贝构造函数还是C#的ICloneable 接口，事实上都是一种拷贝的约定。有了事先的约定，才能约束实现上的统一，所以关键在于设计。 但偶尔也会在后期才想到要深拷贝，怎么办？总不能修改所有之前的实现吧。有没有办法能够通过顶级类而不关心内部的子对象直接进行深拷贝呢？能不 能搞个万能的深拷贝方法，在想用的时候立即用，而不考虑前期的设计。这样“大包大揽”的方法，难点在于实现时必须自动获取子对象的信息，分别为子对象实现 深拷贝。C++里比较困难，.NET的反射机制使得实现容易一些。不过这样的方法虽然通用，实则破坏了封装，也不符合“每个类对自己负责”的设计原则。 & 基于.NET的反射机制，以前写了一个通用的序列化方法，现在可以拿过来，先序列化，然后再反序列化回来，也即是一个深拷贝，示例代码如下：深拷贝示例代码：&&View Code &&&&&&&&#region&ICloneable&Members&&&&&&&&///&&summary&&&&&&&&&///&此处的复制为深拷贝，在实现上，为了简化，采用序列化和反序列化。&&&&&&&&///&&/summary&&&&&&&&&///&&returns&深拷贝对象&/returns&&&&&&&&&public&object&Clone()&&&&&&&&{&&&&&&&&&&&&Student&stu&=&new&Student();&&&&&&&&&&&&XmlStorageHelper&helper&=&new&XmlStorageHelper();&&&&&&&&&&&&string&strXml&=&helper.ConvertToString(this);&&&&&&&&&&&&helper.LoadFromString(stu,&strXml);&&&//从XML字符串来赋值&&&&&&&&&&&&return&&&&&&&&&}&&&&&&&&#endregion
阅读(...) 评论()C#深复制与浅复制
C#中对于数据的复制机制虽然简单但是容易让人误解。C#数据类型大体分为值类型(value
type)与引用类型(reference
type)。对于值类型数据，复制的时候直接将数据复制给另外的变量，而对于引用型变量而言，复制时，其实只是复制了其引用。复制引用的方式叫浅复制，而逐一复制被复制对象的数据成员的方式称为深复制。例如
Person p1=new Person{
& Name=”张三”,//为引用类型
& Address=new
AddressInfo{//AddressInfo为地址信息类，为引用类型
& PostCode=100877,
& District=”beijing”
};//初始化一个Person对象
如果现在有如下语句，
Person p2=p1;
P2.Address=new
AddressInfo{PostCode=100878,District=”shanghai”};
那么，此时p1.Address.PostCode=?
因为Person的Address属性为引用类型，因此，NET默认其复制方式为浅复制，即是说在P2=P1时，将P1.Address的引用传给了P2.Adrress,即是P1.Address与P2.Address指向相同的内存空间。当改变P2的Address属性时，P1.Address属性也会相应改变。因此最后p1.Address.PostCode=100878。
NET中Object类提供了一个MemberwiseClone方法实现的就是上述机制。
要对对象实现深复制。我们可以通过实现ICloneable接口。
ICloneable接口只提供了一个Clone（）抽象方法。只要在类中实现它即可。比如现在我要实现Person类的深复制。则可以如下
Public class Person :ICloneable
& //…………
&public Object &Clone()
Person newPerson =
(Person)this.MemberwiseClone();//先调用默认的复制机制
AddressInfo address=new
AddressInfo{PostCode=this.Address.PostCode,District=this.Address.District};
&newPerson.Address=
return newP&
这样就实现对象的深复制。
可以这样调用(续上面的代码),p2=(Person)p1.Clone();此时再
P2.Address=new
AddressInfo{PostCode=100878,District=”shanghai”};
P1的Address不再改变。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。}