iOS 深拷贝浅拷贝与@property 引用计数关键字Strong,Copy,Weak，Assign

写在文前

相信现在在写OC @property 的时候特别是对 NSString, 都已经习惯的记住了使用 copy 关键字来进行修饰。 然后我看到有些代码里面对 NSDictionary NSArray等对象却依旧在使用 strong，来进行修饰。 我觉得既然 其对象被定义成了 UnMutableObject 我们在定义的时候，就应该想到在其应该是不可变的对象，如果我们违背了这个原则很容易就导致出现一些意想不到的问题。 先来看一段简单的示意代码。

@interface ViewController ()
@property (nonatomic, strong) NSArray *rankArray;
@end
- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    NSMutableArray* dataSour = [NSMutableArray arrayWithObjects:@"90",@"80",@"100",nil];
    // 获取数据，进行展示。 
    self.rankArray = dataSour;
    // 正常显示排行。
    NSLog(@"%@",self.rankArray);
    [dataSour addObject:@"25"];
    //  说好的不可变数组呢？ 为什么？突然冒出来了个 25？ 
    NSLog(@"%@",self.strongName);
}

上面这段小例子告诉我们，为什么在声明 不可变对象的时候，为什么要使用 Copy。而不是Strong。 由于其使用 Strong 导致其声明的时候原本是一个不可变数组，但是在 set 方法中由于没有使用 copy 来进行赋值。 导致自己已经隐形的变成了一个可变数组。 但是如果使用 Copy 来声明的话就不一样的 。 因为不管你源数据类型是可变不可变，进过 Copy 之后最终产物都是 不可变对象。 符合预期结果！！！！！

上面的代码写的很简单，当然我们开发中也不会犯这种错误， 这只是一个简单的比喻。 我们可以想象一下，加入这个是一个B同事开发的接口。 需要A同事需要调用这个接口 把 dataSour 传到 B同事的接口的时候， 如果 A 直接传入一个可变数组进来， 然后后面还修改了这段数据。 那么后面的问题可想而知了！！！！！

简单明了直接上一张, 测试研究结果图，感兴趣了解细节的可以往下看。如果有不正确的地方还望帮忙纠正。

Copy VS MutableCopy

主要通过 NSString、NSMutableString 通过简单的小例子来深入介绍，可变对象和不可变对象使用 copy mutableCopy 得到的结果来说明，理解了 深浅拷贝之 对@property 引用计数关键字的理解和原理就能更加清晰明了。

一、NSString

   //分析字符串 深浅拷贝
- (void)analyzeString
{
    NSString* string = @"StringJerseyCafe";
    // 浅拷贝、未生成新地址、对指针进行了一份拷贝、指向原对象地址所指向的同一份内容。
    NSString* copyString = [string copy];
    // 深拷贝、生成了新的内存地址、对内容也进行了一份拷贝、使用新的内存地址指向新的内容。
    NSMutableString* mutableCopyString = [string mutableCopy];
   // 图一：
    NSLog(@"String = %@-%p --- copyString = %@-%p ---- mutableCopyString = %@-%p/n", string, string, copyString, copyString, mutableCopyString, mutableCopyString);
    // 证明浅拷贝和深拷贝原理。
    string = @"Jersey";
    // 直接改变 string、  其实相当于将 string 重新分配一份内存地址。
    // 从copyString 可以看出、 因为其对 String 的指针地址进行了一份拷贝。 然后使用其同样的内存地址，指向的内容还是同一份。  所以当 string 改变了之后、 并没有影响到自己。
    // mutableCopyString 更加不可能影响，其拷贝了一份内容，然后生成另一份内存地址。 指向拷贝出来的这份内容。
    // 图二：
    NSLog(@"String = %@-%p --- copyString = %@-%p ---- mutableCopyString = %@-%p/n", string, string, copyString, copyString, mutableCopyString, mutableCopyString);
}

[NSSting copy]图一

[NSSting copy]图二

结论： 不可变对象 copy 生成不可变对象,拷贝方式为浅拷贝。 执行 mutableCopy 生成可变对象,拷贝方式为深拷贝。

二、NSMutableString

//分析可变字符串 深浅拷贝
- (void)analyzeMutableString
{
    NSMutableString* mutableString = [NSMutableString stringWithString:@"MutableStringJerseyCafe"];
    // 可变字符串copy、 拷贝其内容，生成一份新地址 指向这份内容。 得到不可变字符串。
    NSMutableString* copyMutableString = [mutableString copy];
    NSMutableString* mutableCopyMutableString = [mutableString mutableCopy];
    // 可变字符串 不管是执行 copy、 mutableCopy 都是深拷贝。 因为其都是生成一份新地址，然后对原有内容进行一份拷贝。使新地址指向拷贝出来的同一份内容。  所以下面的改变原有字符串内容, 也不会两个 深拷贝出来的对象。唯一区别是 copy 得到不可变字符串，mutableCopy 得到可变字符串。 看见下面拼接验证。
    // 图三：
    NSLog(@"mutableString = %@-%p --- copyMutableString = %@-%p ---- mutableCopyMutableString = %@-%p/n", mutableString, mutableString, copyMutableString, copyMutableString, mutableCopyMutableString, mutableCopyMutableString);
    [mutableString appendFormat:@"改变可变字符串内容"];
    NSLog(@"mutableString = %@-%p --- copyMutableString = %@-%p ---- mutableCopyMutableString = %@-%p/n", mutableString, mutableString, copyMutableString, copyMutableString, mutableCopyMutableString, mutableCopyMutableString);
    // 验证 mutableString copy 生成对象。 使用其拼接字符串、  直接导致崩溃、 其属于字符串而非可变字符串。
//    [copyMutableString appendFormat:@"TestcopyMutableString"];
    // 验证 mutableString mutableCopy 生成对象。 使用其拼接字符串、  返回结果正常、 其属于可变字符串而非字符串。
    [mutableCopyMutableString appendFormat:@"TestmutableCopyMutableString"];
    
    NSLog(@"mutableCopyMutableString = %@-%p/n", mutableCopyMutableString, mutableCopyMutableString);
}

[NSSting copy]图三

[NSSting copy]图四

[NSSting copy]图五

结论： 可变对象 copy 生成不可变对象,拷贝方式为深拷贝。 执行 mutableCopy 生成可变对象,拷贝方式为深拷贝。

三、NSString 与 Strong Copy Weak。

@interface ViewController ()

@property (nonatomic, copy) NSString *name;
@property (nonatomic, weak) NSString *weakName;
@property (nonatomic, strong) NSString *strongName;

@end

//使用字符串分析 copy与Strong与Weak 对其set方法有何影响
- (void)analyzeCopyandStrongWithString
{
    NSString *string = @"StringJerseyCafe";
    // copy 修饰的字符串， 在进行 set 方法时, 只是对 当前 string copy，所以结果就跟浅拷贝一样。 复制指针指向同一份内容。并不会对其引用计数器改变。 返回一个 不可变字符串。
    self.name = string;
    // Strong 修饰的字符串， 在进行 set 方法时, 对当前 string retain, 使 string 引用计数器加1, 返回一个不可变字符串。该返回的对象指向 string 的内存地址。
    self.strongName = string;
    // weak 修饰的字符串， 在进行 set 方法时, 只是简单的赋值到当前 属性上。所以 string 引用计数器不变。 self.weakName 使用着 string内存地址，但是不会使 引用计数器加1。
    self.weakName = string;
    // 图六：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", string, string, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
    string = [NSString stringWithFormat:@"对String重新分配内存地址"];
    // 图八：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", string, string, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
    string = nil; // 直接将String 的指向nil;
    // 图九：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", string, string, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
    //  使用三种不同的 引用计数器修饰关键字, 然后对 原有 string 进行内容修改, 指针地址修改, 销毁。 都不会影响到原有属性的指针或者内容,这里具体原因 我没有完全研究明白。 
    //  并且很奇怪的是此 字符串 在只有 weakName 使用的情况下，此时出了 string 作用域，正常应该是已经消耗的。 但是我再 - (void)viewDidAppear:(BOOL)animated 函数 进行测试，发现此 字符串并未释放。 
   //   但是如果使用下面可变字符串的话 则会释放掉。  这个以后有时间在好好研究, 希望大神看到这块可以指点一下。
}
// 测试 weak 对引用计数器的影响。
- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    // 正常
    NSLog(@"测试weak引用是否成功释放%@",self.weakName);
    // 由于self.strongName 制空, 不在对 string 对其引用。此时 string 引用计数器为0 , self.weakName由于也没有对其引用,所以应该直接释放掉了。 但是不知道为什么原因 输出结果表示其并未释放
    self.strongName = nil;
    self.name = nil;
    // 图十：
    NSLog(@"测试weak引用是否成功释放%@",self.weakName);
}

[NSSting copy]图六

[NSSting copy]图八

[NSSting copy]图九

[NSSting copy]图十

结论： 不用的@property 引用计数关键字主要是 set 和 get 方法的影响、 使用 Strong 修饰则在进行 set 方法时 是对当前赋值变量进行了 retain， 使其引用计数器 +1, 使用 Copy 修饰则在进行 set 方法时 是对当前赋值变量进行了 copy，不会使引用计数器 改变。 使用 weak 修饰主要是针对 OC 变量的时候，只是简单的进行了赋值操作 不会对其引用计数器造成变化。 与 assign 一样， 只是 assign 针对非 OC对象。

四、 NSMutableString 与 Strong Copy Weak。

//使用可变字符串分析 copy与Strong 对其set方法有何影响
- (void)analyzeCopyandStrongWithMutableString
{
    NSMutableString *mutableString = [NSMutableString stringWithFormat:@"StringJerseyCafe"];
    // copy 修饰的字符串， 在进行 set 方法时, 只是对 当前 string copy，所以结果就跟浅拷贝一样。 复制指针指向同一份内容。并不会对其引用计数器改变。 返回一个 不可变字符串。
    self.name = mutableString;
    // Strong 修饰的字符串， 在进行 set 方法时, 对当前 string retain, 使 string 引用计数器加1, 返回一个不可变字符串。该返回的对象指向 string 的内存地址。
    self.strongName = mutableString;
    // weak 修饰的字符串， 在进行 set 方法时, 只是简单的赋值到当前 属性上。所以 string 引用计数器不变。 self.weakName 使用着 string内存地址，但是不会使 引用计数器加1。
    self.weakName = mutableString;
    //  由输出结果可以得出、 使用Strong 和 weak 修饰的属性,其指针地址都是跟mutableString一致。 因为其都是使用了mutableString 的指针地址 指向同一块内容,只是Strong 会对 其内存增加一份引用计数器,而weak 不变而已。 
   //  在过来看 copy。 由于其是可变字符串 copy、 其是深拷贝, 所以肯定会生成一份新地址, 然后指向其拷贝出来的相同的一份内容。 所以其地址已经改变了。得到的是一个不可变的字符串。  
   //  所以又这点也证明了为什么我们在写 @property 针对 NSString NSArray NSDictionary 时都要使用 copy 来进行修饰的原因, 这样就成功了确保了 不过你使用 可变对象还是不可变对象 赋值到这个属性的时候 最终结果都是只会得到 不可变的对象。 符合我们的预期结果。
   //  图十一：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", mutableString, mutableString, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
    [mutableString appendFormat:@"对String 内存地址所指向内容进行修改"];
    // 由输出结果可以得出, 由于使用 Strong 和 weak 修饰的属性,其都是在使用 mutableString 地址, 所以当 mutableString 的内容发生改变时, 两个属性同样也是指向这一份改变后的内容的。 但是 Copy 修饰的就不一样了。  由于其是深拷贝出来的, 内存地址完全是独立的,其内容也不可能会发生改变。
   //  图十二：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", mutableString, mutableString, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
    mutableString = [NSMutableString stringWithFormat:@"对String重新分配一份内存地址"];
    // 我们对 mutableString 重新分配内存, Strong 和 weak 修饰的属性还是指向原先的地址和内容, Copy 也是一样。 不会对其造成影响。
   //  图十三：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", mutableString, mutableString, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
    mutableString = nil; // 直接将String 的指向nil;
    //  由输出结果推理 Strong, 此方法只是将 mutableString 的指针地址指向nil。 但是这部分内存还有 Strong 在引用着， 所以并不会释放销毁，所以也不会对Strong 和 weak 造成影响。  
    //  但是如果尝试不对 Strong 进行赋值，单独只有 weak 在引用的话, 出了这个方法作用域, 此内存就会被回收掉。  
    //   尝试- (void)viewDidAppear:(BOOL)animated 进行测试。如果只有 weak 在使用则此内存直接释放。Copy 修饰的同样不会有任何影响， 因为其已经是独立的一份内存地址。
   //  图十四：
    NSLog(@"string = %@-%p --- Name = %@-%p ---- StrongName = %@-%p ---- weakName = %@-%p", mutableString, mutableString, self.name, self.name, self.strongName, self.strongName, self.weakName, self.weakName);
}
// 测试 weak 对引用计数器的影响。
- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    // 正常
    NSLog(@"测试weak引用是否成功释放%@",self.weakName);
    // 由于self.strongName 制空, 不在对 string 对其引用。此时 string 引用计数器为0 , self.weakName由于也没有对其引用,所以应该直接释放掉了。 但是不知道为什么原因 输出结果表示其并未释放
    self.strongName = nil;
    self.name = nil;
    // 图十五：
    NSLog(@"测试weak引用是否成功释放%@",self.weakName);
}

[NSSting copy]图十一

[NSSting copy]图十二

[NSSting copy]图十三

[NSSting copy]图十四

[NSSting copy]图十五

总结：

浅拷贝：将对象的内存地址进行拷贝，不会生成一份新的内存地址。其生成对象与原有对象会公用同一份内存地址 但是它不会改变引用计数器 只会让此内存保持原有引用计数，其所指向的内容是一致的。

深拷贝：将对象的内存地址所指向内容进行拷贝，生成一份新的内存地址指向这份拷贝出来的内容。其生成对象与原有对象分别使用不同的地址，所指向的内容也不一致，其所指向的内容应该是拷贝出来的另一份全新内容。

• strong： 在 set 方法中 ARC 系统会自动帮我们加入对 新值 retain 使其引用计数器 ＋ 1 的代码， 并且对旧 值进行 release 使其引用计数器 － 1 的代码。

• copy： 在 set 方法中 ARC 系统会自动帮我们加入对 新值 copy 的代码。引用计数器不变。

• weak： 在 set 方法中 ARC 系统不会调用 引用计数器相关的 代码执行， 只是简单的赋值而已，所以其引用计数器不会改变。其为OC对象。

• assign：在 set 方法中 ARC 系统不会调用 引用计数器相关的 代码执行， 只是简单的赋值而已，计数器不会改变。其为非OC对象。

写在最后

本文参考了很多前辈的文章及开发中自己总结的结论，希望此篇文章对您有所帮助，如有不对的地方，希望大家能留言指出纠正。欢迎大家一起交流学习 泽西岛上咖啡！！！！！

主要参考文章： iOS 浅谈：深.浅拷贝与copy.strong

测试项目链接 ： https://github.com/ZexiFangkong/LearnDome