IOS 深拷贝和浅拷贝

Posted 2023-05-16

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了IOS 深拷贝和浅拷贝相关的知识，希望对你有一定的参考价值。

参考技术A 一、概念与总结

1、浅拷贝

浅拷贝就是对内存地址的复制，让目标对象指针和源对象指向同一片内存空间，当内存销毁的时候，指向这片内存的几个指针需要重新定义才可以使用，要不然会成为野指针。

浅拷贝就是拷贝指向原来对象的指针，使原对象的引用计数+1，可以理解为创建了一个指向原对象的新指针而已，并没有创建一个全新的对象。

2、深拷贝

深拷贝是指拷贝对象的具体内容，而内存地址是自主分配的，拷贝结束之后，两个对象虽然存的值是相同的，但是内存地址不一样，两个对象也互不影响，互不干涉。

深拷贝就是拷贝出和原来仅仅是值一样，但是内存地址完全不一样的新的对象，创建后和原对象没有任何关系。

3、总结：

深拷贝就是内容拷贝，浅拷贝就是指针拷贝。本质区别在于：

是否开启新的内存地址

是否影响内存地址的引用计数

二、示例分析

在ios中深拷贝与浅拷贝要更加的复杂，涉及到容器与非容器、可变与不可变对象的copy与mutableCopy。下面用示例逐一分析：

1、非集合对象的copy与mutableCopy

1.1 不可变对象NSString

- (void) noMutableNSStringTest

NSString *str1 =@"test001";

NSMutableString *str2 = [str1 copy];

//copy返回的是不可变对象，str2不能被修改，因此会发生崩溃

//[str2 appendString:@"test"];

NSMutableString *str3 = [str1 mutableCopy];

[str3 appendString:@"modify"];

NSLog(@"str1:%p - %@ \r\n",str1,str1);

NSLog(@"str2:%p - %@ \r\n",str2,str2);

NSLog(@"str3:%p - %@ \r\n",str3,str3);

打印结果：

2017-07-2018:02:10.642beck.wang[1306:169414] str1:0x106abdbd0- test001 2017-07-2018:02:10.643beck.wang[1306:169414] str2:0x106abdbd0- test001 2017-07-2018:02:10.643beck.wang[1306:169414] str3:0x608000260940- test001modify

分析：str1、str2地址相同并且与str3地址不同，NSString的copy是浅拷贝，且copy返回的对象是不可变对象；mutableCopy是深拷贝。

1.2 可变对象NSMutableString

- (void) mutableNSStringTest

NSMutableString *mstr1 = [NSMutableString stringWithString:@"test002"];

NSMutableString *mstr2 = [mstr1 copy];

//copy返回的是不可变对象，mstr2不能被修改，因此会发生崩溃

//[str2 appendString:@"test"];

NSMutableString *mstr3 = [mstr1 mutableCopy];

[mstr3 appendString:@"modify"];

NSLog(@"mstr1:%p - %@ \r\n",mstr1,mstr1);

NSLog(@"mstr2:%p - %@ \r\n",mstr2,mstr2);

NSLog(@"mstr3:%p - %@ \r\n",mstr3,mstr3);

打印结果：

2017-07-2018:14:35.789beck.wang[1433:180881] mstr1:0x610000075e40- test002 2017-07-2018:14:35.790beck.wang[1433:180881] mstr2:0xa323030747365747- test002 2017-07-2018:14:35.790beck.wang[1433:180881] mstr3:0x610000074480- test002modify

分析：mstr1、mstr2、mstr3 地址都不同，NSMutableString对象copy与mutableCopy都是深拷贝，且copy返回的对象是不可变对象。

2、集合对象的copy与mutableCopy

2.1 不可变对象NSArray

- (void) mutableNSArrayTest

NSArray *arry1 = [[NSArray alloc] initWithObjects:@"value1",@"value2",nil];

NSArray *arry2 = [arry1 copy];

NSArray *arry3 = [arry1 mutableCopy];

NSLog(@"arry1:%p - %@ \r\n",arry1,arry1);

NSLog(@"arry2:%p - %@ \r\n",arry2,arry2);

NSLog(@"arry3:%p - %@ \r\n",arry3,arry3);

打印结果：

2017-07-2018:33:53.707beck.wang[1502:194476] arry1:0x60800003b480- (

value1,

value2

) 2017-07-2018:33:53.708beck.wang[1502:194476] arry2:0x60800003b480- (

value1,

value2

) 2017-07-2018:33:53.708beck.wang[1502:194476] arry3:0x60800004cd20- (

value1,

value2

)

分析：arry1、arry2 地址一样，arr3 地址不一样，NSArray的copy是浅拷贝，且copy返回的对象是不可变对象；mutableCopy是深拷贝。

2.2 可变对象NSMutableArray

- (void) NSMutableArrayTest

NSMutableArray *marry1 = [[NSMutableArray alloc] initWithObjects:@"value1",@"value2",nil];

NSMutableArray *marry2 = [marry1 copy];

//copy返回的是不可变对象，marry2不能被修改，因此会崩溃

//[marry2 addObject:@"value3"];

NSMutableArray *marry3 = [marry1 mutableCopy];

NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);

NSLog(@"marry2:%p - %@ \r\n",marry2,marry2);

NSLog(@"marry3:%p - %@ \r\n",marry3,marry3);

打印结果：

2017-07-2018:55:43.243beck.wang[1577:204641] marry1:0x600000048d60- (

value1,

value2

) 2017-07-2018:55:43.244beck.wang[1577:204641] marry2:0x600000026000- (

value1,

value2

) 2017-07-2018:55:43.244beck.wang[1577:204641] marry3:0x6000000494b0- (

value1,

value2

)

分析：marry1、marry2、marr3 地址都不一样，NSMutableArray对象copy与mutableCopy都是深拷贝，且copy返回的对象是不可变对象。

特别注意的是：对于集合类的可变对象来说，深拷贝并非严格意义上的深复制，只能算是单层深复制，即虽然新开辟了内存地址，但是存放在内存上的值（也就是数组里的元素仍然之乡员数组元素值，并没有另外复制一份），这就叫做单层深复制。

举例说明：

- (void)singleNSMutableArrayTest

NSMutableArray *marry1 = [[NSMutableArray alloc] init];

NSMutableString *mstr1 = [[NSMutableString alloc]initWithString:@"value1"];

NSMutableString *mstr2 = [[NSMutableString alloc]initWithString:@"value2"];

[marry1 addObject:mstr1];

[marry1 addObject:mstr2];

NSMutableArray *marry2 = [marry1 copy];

NSMutableArray *marry3 = [marry1 mutableCopy];

NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);

NSLog(@"marry2:%p - %@ \r\n",marry2,marry2);

NSLog(@"marry3:%p - %@ \r\n",marry3,marry3);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry2[0],marry2[1]);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry3[0],marry3[1]);

NSLog(@"\r\n------------------修改原值后------------------------\r\n");

[mstr1 appendFormat:@"aaa"];

NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);

NSLog(@"marry2:%p - %@ \r\n",marry2,marry2);

NSLog(@"marry3:%p - %@ \r\n",marry3,marry3);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry2[0],marry2[1]);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry3[0],marry3[1]);

打印结果：

2017-07-2019:48:24.539beck.wang[1750:230132] marry1:0x60800004ae00- (

value1,

value2

) 2017-07-2019:48:24.539beck.wang[1750:230132] marry2:0x608000023f00- (

value1,

value2

) 2017-07-2019:48:24.539beck.wang[1750:230132] marry3:0x60800004abc0- (

value1,

value2

) 2017-07-2019:48:24.540beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.540beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.540beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.540beck.wang[1750:230132] ------------------修改原值后------------------------2017-07-2019:48:24.540beck.wang[1750:230132] marry1:0x60800004ae00- (

value1aaa,

value2

) 2017-07-2019:48:24.540beck.wang[1750:230132] marry2:0x608000023f00- (

value1aaa,

value2

) 2017-07-2019:48:24.540beck.wang[1750:230132] marry3:0x60800004abc0- (

value1aaa,

value2

) 2017-07-2019:48:24.541beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.541beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.541beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb40

分析：在修改原值之前，marry1、marry2、marr3 地址都不一样，很明显copy和mutableCopy都是深拷贝，但是从修改原值后的打印结果来看，这里的深拷贝只是单层深拷贝：新开辟了内存地址，但是数组中的值还是指向原数组的，这样才能在修改原值后，marry2 marr3中的值都修改了。另外，从打印的数组元素地址可以很明显的看出来，修改前后marry1、marry、marr3的数组元素地址都是一模一样的，更加佐证了这一点。

2.3 思维扩展：集合对象的完全深拷贝

2.2中提到了集合类的对象来说，深拷贝只是单层深拷贝，那有没有办法实现每一层都深拷贝呢？回答是肯定的，目前我们可以这么做：

（1）归档解档大法

- (void) deplyFullCopy

NSMutableArray *marry1 = [[NSMutableArray alloc] init];

NSMutableString *mstr1 = [[NSMutableString alloc]initWithString:@"value1"];

NSMutableString *mstr2 = [[NSMutableString alloc]initWithString:@"value2"];

[marry1 addObject:mstr1];

[marry1 addObject:mstr2];

NSData *data = [NSKeyedArchiver archivedDataWithRootObject:marry1];

NSArray *marray2 = [NSKeyedUnarchiver unarchiveTopLevelObjectWithData:data error:nil];

NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);

NSLog(@"marry2:%p - %@ \r\n",marray2,marray2);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marray2[0],marray2[1]);

打印结果：

2017-07-2020:04:38.726beck.wang[1833:242158] marry1:0x600000048a00- (

value1,

value2

) 2017-07-2020:04:38.726beck.wang[1833:242158] marry2:0x600000049780- (

value1,

value2

) 2017-07-2020:04:38.726beck.wang[1833:242158] 数组元素地址:value1:0x600000066300- value2:0x6000000670002017-07-2020:04:38.726beck.wang[1833:242158] 数组元素地址:value1:0x600000066740- value2:0x600000066f40

分析：我们可以看到，开辟了新的内存地址的同时，数组元素的指针地址也不同了，实现了完全的深拷贝。

（2）- (instancetype)initWithArray:(NSArray<ObjectType> *)array copyItems:(BOOL)flag;

- (void) deplyFullCopy2

NSMutableArray *marry1 = [[NSMutableArray alloc] init];

NSMutableString *mstr1 = [[NSMutableString alloc]initWithString:@"value1"];

NSMutableString *mstr2 = [[NSMutableString alloc]initWithString:@"value2"];

[marry1 addObject:mstr1];

[marry1 addObject:mstr2];

NSArray *marray2 = [[NSArray alloc] initWithArray:marry1 copyItems:YES];

NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);

NSLog(@"marry2:%p - %@ \r\n",marray2,marray2);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);

NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marray2[0],marray2[1]);

打印结果：

2017-07-2020:08:04.201beck.wang[1868:246161] marry1:0x610000050320- (

value1,

value2

) 2017-07-2020:08:04.202beck.wang[1868:246161] marry2:0x6100002214c0- (

value1,

value2

) 2017-07-2020:08:04.202beck.wang[1868:246161] 数组元素地址:value1:0x610000265600- value2:0x6100002664002017-07-2020:08:04.202beck.wang[1868:246161] 数组元素地址:value1:0xa003165756c61766- value2:0xa003265756c61766

分析：同上。

三、准则

No1：可变对象的copy和mutableCopy方法都是深拷贝（区别完全深拷贝与单层深拷贝）。

No2：不可变对象的copy方法是浅拷贝，mutableCopy方法是深拷贝。

No3：copy方法返回的对象都是不可变对象。

万语千言汇成一张图

深拷贝和浅拷贝怎样理解（通俗具体点儿）

在C＃中

1.深拷贝与浅拷贝拷贝即是通常所说的复制(Copy)或克隆(Clone)，对象的拷贝也就是从现有对象复制一个“一模一样”的新对象出来。虽然都是复制对象，但是不同的复制方法，复制出来的新对象却并非完全一模一样，对象内部存在着一些差异。通常的拷贝方法有两种，即深拷贝和浅拷贝，那二者之间有何区别呢？MSDN里对IClone接口的Clone方法有这样的说明：在深层副本中，所有的对象都是重复的；而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引用。可以看出，深拷贝和浅拷贝之间的区别在于是否复制了子对象。这如何理解呢？下面我通过带有子对象的代码来验证二者的区别。首先定义两个类型：Student和ClassRoom，其中Student类型里包含ClassRoom，并使这两个类型都分别实现自定义的深拷贝接口(IDeepCopy)和浅拷贝接口(IShallowCopy)。类图如下：定义代码如下：定义代码 /// <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=" + RoomName; public object DeepCopy() ClassRoom r = new ClassRoom(); r.RoomID = this.RoomID; r.RoomName = this.RoomName; return r; public object ShallowCopy() //直接使用内置的浅拷贝方法返回 return this.MemberwiseClone(); class Student : IDeepCopy, IShallowCopy //为了简化，使用public 字段 public string Name; public int Age; //自定义类型，假设每个Student只拥有一个ClassRoom public ClassRoom Room = new ClassRoom(); public Student() public Student(string name, int age) this.Name = name; this.Age = age; public object DeepCopy() Student s = new Student(); s.Name = this.Name; s.Age = this.Age; 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(); 测试代码：测试代码 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的反射机制，以前写了一个通用的序列化方法，现在可以拿过来，先序列化，然后再反序列化回来，也即是一个深拷贝，示例代码如下：深拷贝示例代码 #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 stu; #endregion 参考技术A 　　浅拷贝：也就是在对象复制时，只是对对象中的数据成员进行简单的赋值，如果对象中存在动态成员，即指针，浅拷贝就会出现问题。
　　深拷贝：对于深拷贝，针对成员变量存在指针的情况，不仅仅是简单的指针赋值，而是重新分配内存空间。
　　浅拷贝，即在定义一个类A，使用类似Aobj;Aobj1(obj);或者Aobj1=obj;时候，由于没有自定义拷贝构造函数，C++编译器自动会产生一个默认的拷贝构造函数。
　　这个默认的拷贝构造函数采用的是“位拷贝”（浅拷贝），而非“值拷贝”（深拷贝）的方式，如果类中含有指针变量，默认的拷贝构造函数必定出错。
　　用一句简单的话来说就是浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。
　　假如有一个成员变量的指针，char*m_data;
　　其一，浅拷贝只是拷贝了指针，使得两个指针指向同一个地址，这样在对象块结束，调用函数析构的时，会造成同一份资源析构2次，即delete同一块内存2次，造成程序崩溃。
　　其二，浅拷贝使得obj.m_data和obj1.m_data指向同一块内存，任何一方的变动都会影响到另一方。
　　其三，在释放内存的时候，会造成obj1.m_data原有的内存没有被释放，造成内存泄露。
　　事实是这样的，当deleteobj.m_data,obj.m_data内存被释放后，由于之前obj.m_data和obj1.m_data指向的是同一个内存空间，obj1.m_data所指的空间不能在被利用了，deleteobj1.m_data也不会成功，一致已经无法操作该空间，所以导致内存泄露。
　　深拷贝采用了在堆内存中申请新的空间来存储数据，这样每个可以避免指针悬挂。
　　可以看到在拷贝构造函数中为成员变量申请了新的内存空间，这就使得两个对象的成员变量不指向同一个内存空间，除非你的确需要这样做，用于实现一些其他的用途。

以上是关于IOS 深拷贝和浅拷贝的主要内容，如果未能解决你的问题，请参考以下文章