相信现在在写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 直接传入一个可变数组进来， 然后后面还修改了这段数据。 那么后面的问题可想而知了。

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

4053578-42c72941a2283e9b.png

Copy VS MutableCopy.png

主要通过 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]图一.png

[NSSting copy]图二.png

结论： 不可变对象 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]图三.png

[NSSting copy]图四.png

[NSSting copy]图五.png

结论： 可变对象 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]图六.png

[NSSting copy]图七.png

[NSSting copy]图八.png

[NSSting copy]图九.png

结论： 不用的@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 方法时, 只是对 当前 NSMutableString copy，所以结果是深拷贝 得到一个 NSString 对象。 生成新对象指针指向同一份内容。也并不会对其引用计数器改变。 返回一个 不可变字符串。 
    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]图十.png

[NSSting copy]图十一.png

[NSSting copy]图十二.png

[NSSting copy]图十三.png

[NSSting copy]图十四.png

总结：

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

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

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

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

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

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