深拷贝和浅拷贝问题

深拷贝浅拷贝的问题,假如我们现在有两个类A、B,然后类A中有一个属性是B类,这个时候我们把A的一个对象a1赋值给了另外一个变量a2,这个时候更改a2中的属性,如 string 、int 的值,然后在输出a2的值,a1的值就会发现没有发生什么问题 ,a2中更改的值不会影响a1中的值。但是如果我们更改a2中的B的属性,然后就会看到a1中的B属性值也在发生改变,发生的这个问题就叫做浅拷贝;如果更改a2中的B的属性,那么a1的B属性不会随之而更改,这个时候就叫做深拷贝,浅拷贝我们可以通过字段一个个的赋值,也可以通过实现ICloneable来实现,实现深拷贝就需要使用序列化来实现了。

一个类如果实现了ICloneable,我们就可以进行浅拷贝了,实现浅拷贝代码如下,eg:

public class Person : ICloneable
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Tool Tool { get; set; }

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

public class Tool
{
    public string Name { get; set; }
}

实现代码

protected void Page_Load(object sender, EventArgs e)
{
    Person p1 = new Person();
    p1.Name = "wenbin";
    p1.Age = 20;
    Tool tool = new Tool();
    tool.Name = "杠杆";
    p1.Tool = tool;
    Person p2 = new Person();
    p2 = p1;//浅拷贝
    p2.Age = 30;
    p2.Tool.Name = "shit";
    Response.Write(p1.Age + p1.Name + p1.Tool.Name);
    Response.Write(p2.Age + p2.Name + p2.Tool.Name + "<br/>");

    Person p3 = new Person();
    p3 = p1.Clone() as Person; //浅拷贝
    p3.Age = 40;
    p3.Tool.Name = "fuck";
    Response.Write(p1.Age + p1.Name + p1.Tool.Name);
    Response.Write(p3.Age + p3.Name + p3.Tool.Name);
}

下面讲解一下深拷贝,深拷贝我们就需要使用序列化了,这里用到的是一个内存流,因为内存流的读取熟读快并且不需要在本地创建文件,性能相对来讲也会好一些,类还是刚才的类,只不过在每一个类上面都添加了一个Attribute,[Serializable],如果我们只给Person添加一个Serializable而不给Tool添加Serializable的话,会报错的。代码如下,eg:

[Serializable]
public class Person : ICloneable
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Tool Tool { get; set; }

    public object Clone()
    {
        return this.MemberwiseClone();
    }
}
[Serializable]
public class Tool
{
    public string Name { get; set; }
}

实现方法

protected void Page_Load(object sender, EventArgs e)
{
    Person p1 = new Person();
    p1.Name = "wenbin";
    p1.Age = 20;
    Tool tool = new Tool();
    tool.Name = "杠杆";
    p1.Tool = tool;
    Person p2 = new Person();

    BinaryFormatter bf = new BinaryFormatter();
    byte[] myBytes = new byte[1024];
    using (MemoryStream ms = new MemoryStream(myBytes))
    {
    bf.Serialize(ms, p1);
    }
    using (MemoryStream ms = new MemoryStream(myBytes))
    {
    p2 = bf.Deserialize(ms) as Person;
    }
    p2.Tool.Name = "汽车";
    Response.Write(p1.Age + p1.Name + p1.Tool.Name);
    Response.Write(p2.Age + p2.Name + p2.Tool.Name + "<br/>");
}

这里我们就可以通过深拷贝来实现数据的更改而不会影响到前面的对象了。

时间: 2024-10-11 02:36:59

深拷贝和浅拷贝问题的相关文章

【转载】C++拷贝构造函数(深拷贝,浅拷贝)

对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. #include <iostream>using namespace std;class CExample {private:     int a;public:     CExample(int b)     { a=b;}     void Show ()     {        cout<

完全理解python深拷贝和浅拷贝

import copya = [1, 2, 3, 4, ['a', 'b']]  #原始对象b = a  #赋值,传对象的引用c = copy.copy(a)  #对象拷贝,浅拷贝d = copy.deepcopy(a)  #对象拷贝,深拷贝a.append(5)  #修改对象aa[4].append('c')  #修改对象a中的['a', 'b']数组对象print 'a = ', aprint 'b = ', bprint 'c = ', cprint 'd = ', d 输出结果:a = 

javaScript之深拷贝与浅拷贝

js中有两种数据类型: 1.  基本类型  :  Number.String.Boolean.Null.Undefined 2.  复杂类型  :  Object .Array 深拷贝和浅拷贝只针对复杂类型的数据,因为基本类型数据的定义都会重新开辟新的内存. 浅拷贝拷贝的是内存地址,只是增加一个指针指向已有的内存,这时多个数据共用一个内存空间:深拷贝是新增了指针并且新开辟了内存空间,新指针指向新的内存. 浅拷贝: var a={ name:'WangJing', sex:'女', age:'25

C++拷贝构造函数(深拷贝,浅拷贝)

http://www.cnblogs.com/BlueTzar/articles/1223313.html 对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 1 #include <iostream> 2 using namespace std; 3 4 class CExample { 5 private: 6 int a; 7 public: 8

python 中 深拷贝和浅拷贝的理解

在总结 python 对象和引用的时候,想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解. 在python中,对象的赋值的其实就是对象的引用.也就是说,当创建一个对象,然后赋给另外一个变量之后,实际上只是拷贝了这个对象的引用. 我们先用  利用切片操作和工厂方法list方法 来阐述一下浅拷贝. 举个栗子: Tom = ['Tom', ['age', 10]] Jack = Tom[:] ……切片操作 June = list(Tom) 接下来查看一下 上述三个变量的引用: >>

实现CMyString类--深拷贝与浅拷贝

实现CMyString类,实现赋值运算符函数(深拷贝与浅拷贝(写时拷贝)) 深拷贝:赋值运算符函数说明 步骤1.释放原来的内存空间 步骤2.再重新开辟要赋值的对象的大小的空间 步骤3.再将另一个对象的值拷贝给this对象 友元函数的说明:由于输出重载需要俩个参数,不能再隐含this指针,故使用友元函数 代码如下: <span style="font-size:18px;">class CMyString { public: CMyString() :str(new char

python 深拷贝和浅拷贝之可变和不可变对象总结

了解深拷贝和浅拷贝之前先要理解可变与不可变对象 python只允许使用引用传递,有可变对象和不可变对象,可变对象:list,dict.不可变对象有:int,string,float,tuple Python int,string,float,tuple不可变举栗子: def int_object(): i = 89 j = 89 print(id(89)) print('i id:' + str(id(i))) print('j id:' + str(id(j))) print(i is j)

深拷贝与浅拷贝

一.浅拷贝和深拷贝 所谓浅拷贝,就是由默认的拷贝构造函数所实现的对数据成员逐一赋值.若类中含有指针类型的数据,这种方式只是简单的把指针的指向赋值给新成员,但并没有给新成员分配内存,因此这种方式必然会导致错误.为了解决浅拷贝出现的错误,必须显示的定义一个拷贝构造函数,使之不但复制数据成员,而且为对象分配各自的内存空间,这就是所谓的深拷贝. 二.浅拷贝 浅拷贝就是由默认的拷贝构造函数所实现的数据成员逐一赋值.通常默认的拷贝构造函数能够胜任这个工作,但是若类中含有指针类型的数据,这种数据成员逐一赋值的

【转】 C++的深拷贝与浅拷贝

对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <iostream> using namespace std; class CExample { private:      int a; public:      CE

python 深拷贝与浅拷贝

浅拷贝的方式有: lst=[1,2,3] (1)直接赋值: lst_cp = lst (2)for循环遍历生成:lst_cp= [i for i in lst] (3)copy模块下,copy.copy仍为浅拷贝 深拷贝的方式 (1)借助copy模块 >>> import copy >>> lst_cp = copy.deepcopy(lst) 以上方法的测试: 注意:因为string类型是不可变类型,所以修改string元素时会新创建一个地址空间放置数据 (1)直接赋