iOS-copy与mutableCopy浅析
在iOS开发中，当提到深拷贝和浅拷贝的时候，大家都说懂，简单；都会说，浅拷贝：指针（地址）拷贝，不会产生新对象；深拷贝：内容拷贝，会产生新对象，但当问及大家copy与mutableCopy的时候，他们各自是深拷贝还是浅拷贝的时候，谁又有底气答对呢？下面一起研究下吧
1、不可变字符串的拷贝
NSString *string = @&string&;
NSString *str1 = [string copy];
// 没有产生新对象 【浅拷贝】
NSMutableString *str2 = [string mutableCopy];
// 产生新对象
【深拷贝】
NSLog(@&%p %p %p&, string, [string copy], [string mutableCopy]);
打印结果如下：
根据打印结果解析：
当不可变字符串调用copy的时候，指针地址没有发生改变，也就意味着没有产生新的对象，所以属于浅拷贝；
当不可变字符串调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
2、可变字符串的拷贝
NSMutableString *string = [NSMutableString string];
[string appendString:@&text1&];
NSString *str1 = [string copy];
// 产生新对象,变为不可变字符串【深拷贝】
NSMutableString *str2 = [string mutableCopy];// 产生新对象,还是可变字符串
【深拷贝】
[str2 appendString:@&text2&];
NSLog(@&%p %p %p&, string, [string copy], [string mutableCopy]);
NSLog(@&%@ %@ %@&, string, str1, str2);
打印结果如下：
根据打印结果解析：
当可变字符串调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝；
当可变字符串调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
3、不可变数组的拷贝
NSArray *array = @[@&text1&, @&text2&];
NSArray *array1 = [array copy];
// 没有产生新对象
【浅拷贝】
NSMutableArray *array2 = [array mutableCopy]; // 产生新对象,变为可变数组【深拷贝】
[array2 addObject:@&text3&];
NSLog(@&%p %p %p&, array, array1, array2);
NSLog(@&%@ %@ %@&, array, array1, array2);
打印结果如下：
根据打印结果解析：
当不可变数组调用copy的时候，指针地址没有发生改变，意味着没有产生新的对象，所以属于浅拷贝；
当不可变数组调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
4、可变数组的拷贝
NSMutableArray *mutableArray = @[@&text1&, @&text2&].mutableC
NSArray *array1 = [mutableArray copy];
// 产生新对象,变为不可变数组【深拷贝】
NSMutableArray *mutableArray1 = [mutableArray mutableCopy]; // 产生新对象,变为可变数组
【深拷贝】
[mutableArray1 addObject:@&text3&];
NSLog(@&%p %p %p&, mutableArray, [mutableArray copy], [mutableArray mutableCopy]);
NSLog(@&%@ %@ %@&, mutableArray, array1, mutableArray1);
打印结果如下：
根据打印结果解析：
当可变数组调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝；
当可变数组调用mutableCopy的时候，指针地址发生了改变，意味着产生新的对象，所以属于深拷贝。
5、自定义对象的拷贝
由于自定义对象不考虑可变，所以忽略mutableCopy
首先，当对象需要调用 copy 的时候，需要遵守遵守 NSCopying 协议 和 调用 copyWithZone：这个方法
@interface Dog : NSObject
/** 姓名 */
@property (nonatomic, copy) NSString *
/** 年龄 */
@property (nonatomic, assign)
// 需要遵守 NSCopying 协议
@interface Dog ()
@implementation Dog
// 当对象需要调用 copy 的时候，需要调用 copyWithZone：这个方法
- (id)copyWithZone:(NSZone *)zone
Dog *dog = [[Dog allocWithZone:zone] init];
dog.name = self.
Dog *dog = [[Dog alloc] init]; // [object copyWithZone:zone]
dog.name = @&huahua&;
Dog *newDog = [dog copy]; // 产生新对象【深拷贝】
NSLog(@&%@ %@&,dog,newDog);
NSLog(@&%@ %@&,dog.name,newDog.name);
打印结果如下：
根据打印结果解析：
当自定义对象调用copy的时候，指针地址发生了改变，也就意味着产生新的对象，所以属于深拷贝；
6、属性中的copy 和 strong
在平时定义属性的时候，对于NSString 和 block 我们经常用 copy 来修饰
数组和字典等类型用 strong 来修饰；
当使用 copy 修饰属性的时候，属性的setter方法会调用[object copy]产生新的对象，
这样，当原object对象的值发生改变时，并不影响新对象值；
// 定义NSString
@property(nonatomic, copy) NSString *
// 当调用上面的copy的时候，等价于下面的代码
- (void)setName:(NSString *)name {
if (_name != name) {
[_name release];
_name = [name copy];
当使用 strong 修饰属性的时候，属性的setter方法会直接强引用该对象，
这样，当原object对象的值发生改变时，新对象的属性也改变；
例如：我们平时使用strong修饰的NSMutableArray，这个可变数组在当前文件中只有一个，而且是可变的;
/** 数组 */
@property(nonatomic,strong)NSMutableArray *
// 当调用上面的strong的时候，等价于下面的代码
-(void)setArray:(NSMutableArray *)array{
以前面的自定义Dog对象进行举例：
// 定义一个可变的字符，作为小狗的name
NSMutableString *dogName = [NSMutableString stringWithString:@&huahua&];
// dogName == &huahua&
Dog *dog = [[Dog alloc] init];
// 将字符赋值给dog的name属性
dog.name = dogN
// 当小狗的name值发生改变时
[dogName appendString:@&lvlv&];
// dogName == &huahualvlv&
// 小狗的名还是原来的姓名
NSLog(@&%@&,dog.name);
// 打印结果：huahua
分析：当给dog.name 赋值时，会将 [dogName copy] 后的结果赋值给 dog.name，这样,当dogName字符的值发生改变后，不会影响 dog.name 的值；
总结：当不可变类型对象调用copy拷贝后，不会产生新的对象，属于浅拷贝，其他类型对象不管调用copy亦或是mutableCopy，都会产生新的对象，属于深拷贝！他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)iOS中copy,strong,retain,weak和assign的区别 - 简书
iOS中copy,strong,retain,weak和assign的区别
本文逻辑图：
文章逻辑图
在知道他们区别之前，我们首先要知道NSObject对象的赋值操作做了哪些操作。
A=C其实是在内存中创建了一个A，然后又开辟了一个内存C，C里面存放的着值B。
NSObject赋值示意图1
NSMutableString*tempMStr = [[NSMutableString alloc]initWithString:@"strValue"];
NSLog(@"tempMStr值地址:%p，tempMStr值%@,tempMStr值引用计数%@\\n", tempMStr,tempMStr,[tempMStr valueForKey:@"retainCount"]);
//输出tempMStr值地址:0x7a05f650，tempMStr值strValue,tempMStr值引用计数1
此处tempMStr就是A，值地址就是C，“strValue”就是B，而引用计数这个概念是针对C的，赋值给其他变量或者指针设置为nil，如tempStr = nil，都会使得引用计数有所增减。当内存区域引用计数为0时就会将数据抹除。而我们使用copy,strong,retain,weak,assign区别就在：
1.是否开辟新的内存
2.是否对地址C有引用计数增加
需要注意的是property修饰符是在被赋值时起作用。
1.以典型的NSMutableString为例
@property(copy,nonatomic)NSMutableString*aCopyMS
@property(strong,nonatomic)NSMutableString*strongMS
@property(weak,nonatomic)NSMutableString*weakMS
@property(assign,nonatomic)NSMutableString*assignMS
NSMutableString*mstrOrigin = [[NSMutableStringalloc]initWithString:@"mstrOriginValue"];
self.aCopyMStr= mstrO
self.strongMStr= mstrO
self.strongMStr= mstrO
self.weakMStr= mstrO
NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
NSLog(@"aCopyMStr输出:%p,%@\\n",_aCopyMStr,_aCopyMStr);
NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
NSLog(@"引用计数%@",[mstrOriginvalueForKey:@"retainCount"]);
//输出结果
// 15:19:13.134 lbCopy[] mstrOrigin输出:0x,mstrOriginValue
// 15:19:13.135 lbCopy[] aCopyMStr输出:0x7893deb0,mstrOriginValue
// 15:19:13.135 lbCopy[] strongMStr输出:0x,mstrOriginValue
// 15:19:13.135 lbCopy[] weakMStr输出:0x,mstrOriginValue
// 15:19:13.135 lbCopy[] 引用计数2
strongMStr和weakMStr指针指向的内存地址都和mstrOrigin相同,但mstrOrigin内存引用计数为2，不为3，因为weakMStr虽然指向了数据内存地址（之后用C简称，见示意图1），但不会增加C计数。copy修饰的的aCopyMStr，赋值后则是自己单独开辟了一块内存，内存上保存“mstrOrigin”字符串，并指向。
拷贝示意图如下
NSMutableString拷贝示意图2
可见当我修改mstrOrigin的值的时候，必然不会影响aCopyMStr,只会影响strongMStr和weakMStr。我们来验证下
NSLog(@"------------------修改原值后------------------------");
[mstrOriginappendString:@"1"];
NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
NSLog(@"aCopyMStr输出:%p,%@\\n",_aCopyMStr,_aCopyMStr);
NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
//输出结果
// 15:33:02.839 lbCopy[] mstrOrigin输出:0x,mstrOrigin1
// 15:33:02.839 lbCopy[] aCopyMStr输出:0x7893deb0,mstrOrigin
// 15:33:02.839 lbCopy[] strongMStr输出:0x,mstrOrigin1
// 15:33:02.839 lbCopy[] weakMStr输出:0x,mstrOrigin1
copy会重新开辟新的内存来保存一份相同的数据。被赋值对象和原值修改互不影响。strong和weak赋值都指向原来数据地址，区别是前者会对数据地址进行引用计数+1，后者不会
引用计数是否+1有什么实质区别呢？
如果知道“值地址的引用计数为0时，地址上保存的值就会被释放”。那么区别就不难理解，weak修饰的指针A指向的值地址C，那么地址上当其他指向他的指针被释放的时候，这个值地址引用计数也就变为0了，这个A的值也就为nil了。换句话说当值地址C上没有其他强引用指针修饰的时候C就会被立即释放，A的值就变为nil了。
这里我们来初始化mstrOrigin和并将strongMStr设置为nil让C的引用计数为0，然后输出weakMStr，看是否为nil.
注：初始化和设为nil都可以将指针所指向的数据地址引用计数减少1
mstrOrigin = [[NSMutableStringalloc]initWithString:@"mstrOriginChange2"];
self.strongMStr=
NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
// 15:41:33.793 lbCopy[] mstrOrigin输出:0x,mstrOriginChange2
// 15:41:33.793 lbCopy[] strongMStr输出:0x0,(null)
// 15:41:33.794 lbCopy[] weakMStr输出:0x0,(null)
可见之前引用计数2是mstrOrigin和strongMStr添加的。
结论：copy会重新开辟新的内存来保存一份相同的数据。被赋值对象和原值修改互不影响。strong和weak虽然都指向原来数据地址，原值修改的时候storng和weak会随之变化。区别是前者会对数据地址进行引用计数+1防止原地址值被释放，但后者不会，当其他值都不在指向值地址时，值地址被释放，weak的值也就是为nil了。我们称会对数据地址增加引用计数的为强引用，不改变引用计数的为弱引用
1.2 assign和weak的区别
对assign和weak修饰的值进行赋值，并输出指针结构地址和值
self.assignMStr= mstrO
self.weakMStr= mstrO
mstrOrigin = [[NSMutableStringalloc]initWithString:@"mstrOriginChange3"];
NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
NSLog(@"assignMStr输出:%p,%@\\n",self.assignMStr,self.assignMStr);
可以发现在输出assignMStr时会偶尔出现奔溃的情况。原因是发送了野指针的情况。assign同weak，指向C并且计数不+1，但当C地址引用计数为0时，assign不会对C地址进行B数据的抹除操作，只是进行值释放。这就导致野指针存在，即当这块地址还没写上其他值前，能输出正常值，但一旦重新写上数据，该指针随时可能没有值，造成奔溃。
1.3那retain是什么
ARC之前属性构造器的关键字是retain,copy,assign，strong和weak是ARC带出来的关键字。
retain现在同strong，就是指针指向值地址，同时进行引用计数加1。
2.非NSMutableString的情况
上面我们讨论了典型的例子NSMutableString，即非容器可变变量。也就是说还存在其他三种类型需要讨论...
1.非容器不可变变量NSSting
2.容器可变变量NSMutableArray
3.容器不可变变量NSArray
更重要的是不同类型会有不同结果...，好吧，不要奔溃，上面一大段我们讨论了1/4，接下来我们要讨论其他的3/4情况。但好消息是，其他几种情况基本与上面非容器可变变量情况基本类似。
2.1容器可变变量
容器可变变量的典型例子就是NSMutableArray
下面代码可以忽略，只做参考用
@property(copy,nonatomic)NSMutableArray*aCopyMA
@property(strong,nonatomic)NSMutableArray*strongMA
@property(weak,nonatomic)NSMutableArray*weakMA
NSMutableArray*mArrOrigin = [[NSMutableArrayalloc]init];
NSMutableString*mstr1 = [[NSMutableStringalloc]initWithString:@"value1"];
NSMutableString*mstr2 = [[NSMutableStringalloc]initWithString:@"value2"];
NSMutableString*mstr3 = [[NSMutableStringalloc]initWithString:@"value3"];
[mArrOriginaddObject:mstr1];
[mArrOriginaddObject:mstr2];
//将mArrOrigin拷贝给aCopyMArr，strongMArr，weakMArr
self.aCopyMArr= mArrO
self.strongMArr= mArrO
self.weakMArr= mArrO
NSLog(@"mArrOrigin输出:%p,%@\\n", mArrOrigin,mArrOrigin);
NSLog(@"aCopyMArr输出:%p,%@\\n",_aCopyMArr,_aCopyMArr);
NSLog(@"strongMArr输出:%p,%@\\n",_strongMArr,_strongMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr,_weakMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr[0],_weakMArr[0]);
NSLog(@"mArrOrigin中的数据引用计数%@", [mArrOriginvalueForKey:@"retainCount"]);
NSLog(@"%p %p %p %p",&mArrOrigin,mArrOrigin,mArrOrigin[0],mArrOrigin[1]);
//以下是输出
20:42:30.777 lbCopy[] mArrOrigin输出:0x78f81680,(
20:42:30.777 lbCopy[] aCopyMArr输出:0x7a041340,(
20:42:30.777 lbCopy[] strongMArr输出:0x78f81680,(
20:42:30.777 lbCopy[] weakMArr输出:0x78f81680,(
20:42:30.777 lbCopy[] weakMArr输出:0x78f816a0,value1
20:42:30.778 lbCopy[] mArrOrigin中的数据引用计数(
20:42:30.778 lbCopy[] 0xbffbff816a0 0x78f81710
//以上是输出
//给原数组添加一个元素
[mArrOriginaddObject:mstr3];
NSLog(@"mArrOrigin输出:%p,%@\\n", mArrOrigin,mArrOrigin);
NSLog(@"aCopyMArr输出:%p,%@\\n",_aCopyMArr,_aCopyMArr);
NSLog(@"strongMArr输出:%p,%@\\n",_strongMArr,_strongMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr,_weakMArr);
NSLog(@"mArrOrigin中的数据引用计数%@", [mArrOriginvalueForKey:@"retainCount"]);
//修改原数组中的元素，看是否有随之变化
[mstr1appendFormat:@"aaa"];
NSLog(@"mArrOrigin输出:%p,%@\\n", mArrOrigin,mArrOrigin);
NSLog(@"aCopyMArr输出:%p,%@\\n",_aCopyMArr,_aCopyMArr);
NSLog(@"strongMArr输出:%p,%@\\n",_strongMArr,_strongMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr,_weakMArr);
//以下是输出
20:42:30.778 lbCopy[] mArrOrigin输出:0x78f81680,(
20:42:30.778 lbCopy[] aCopyMArr输出:0x7a041340,(
20:42:30.778 lbCopy[] strongMArr输出:0x78f81680,(
20:42:30.778 lbCopy[] weakMArr输出:0x78f81680,(
20:42:30.779 lbCopy[] mArrOrigin中的数据引用计数(
20:42:30.779 lbCopy[] mArrOrigin输出:0x78f81680,(
value1aaa,
20:42:30.779 lbCopy[] aCopyMArr输出:0x7a041340,(
value1aaa,
20:42:30.779 lbCopy[] strongMArr输出:0x78f81680,(
value1aaa,
20:42:30.779 lbCopy[] weakMArr输/出:0x78f81680,(
value1aaa,
//以上是输出
上面代码有点多，所做的操作是mArrOrigin（value1,value2）赋值给copy,strong,weak修饰的aCopyMArr,strongMArr,weakMArr。通过给原数组增加元素，修改原数组元素值，然后输出mArrOrigin的引用计数，和数组地址，查看变化。
发现其中数组本身指向的内存地址除了aCopyMArr重新开辟了一块地址，strongMArr,weakMArr和mArrOrigin指针指向的地址是一样的。也就是说
容器可变变量中容器本身和非容器可变变量是一样的，copy深拷贝，strongMArr,weakMArr和assign都是浅拷贝
另外我们发现被拷贝对象mArrOrigin中的数据引用计数居然不是1而是3。也就是说容器内的数据拷贝都是进行了浅拷贝。同时当我们修改数组中的一个数据时strongMArr,weakMArr，aCopyMArr中的数据都改变了，说明
容器可变变量中的数据在拷贝的时候都是浅拷贝
容器可变变量的拷贝结构如下图
NSMutableArray拷贝示意图3
2.2非容器不变变量
典型例子是NSString
我们还是以代码引出结果
@property(copy,nonatomic)NSString*aCopyS
@property(strong,nonatomic)NSString*strongS
@property(weak,nonatomic)NSString*weakS
@property(assign,nonatomic)NSString*assignS
NSLog(@"\\n\\n\\n\\n------------------不可变量实验------------------------");
NSString*strOrigin = [[NSStringalloc]initWithUTF8String:"strOrigin0123456"];
self.aCopyStr= strO
self.strongStr= strO
self.weakStr= strO
NSLog(@"strOrigin输出:%p,%@\\n", strOrigin,strOrigin);
NSLog(@"aCopyStr输出:%p,%@\\n",_aCopyStr,_aCopyStr);
NSLog(@"strongStr输出:%p,%@\\n",_strongStr,_strongStr);
NSLog(@"weakStr输出:%p,%@\\n",_weakStr,_weakStr);
NSLog(@"------------------修改原值后------------------------");
strOrigin =@"aaa";
NSLog(@"strOrigin输出:%p,%@\\n", strOrigin,strOrigin);
NSLog(@"aCopyStr输出:%p,%@\\n",_aCopyStr,_aCopyStr);
NSLog(@"strongStr输出:%p,%@\\n",_strongStr,_strongStr);
NSLog(@"weakStr输出:%p,%@\\n",_weakStr,_weakStr);
NSLog(@"------------------结论------------------------");
NSLog(@"strOrigin值值为改变，但strOrigin和aCopyStr指针地址和指向都已经改变，说明不可变类型值不可被修改，重新初始化");
self.aCopyStr=
self.strongStr=
NSLog(@"strOrigin输出:%p,%@\\n", strOrigin,strOrigin);
NSLog(@"aCopyStr输出:%p,%@\\n",_aCopyStr,_aCopyStr);
NSLog(@"strongStr输出:%p,%@\\n",_strongStr,_strongStr);
NSLog(@"weakStr输出:%p,%@\\n",_weakStr,_weakStr);
NSLog(@"------------------结论------------------------");
NSLog(@"当只有weakStr拥有C时，值依旧会被释放，同非容器可变变量");
//以下是输出
------------------不可变量实验------------------------
21:08:44.053 lbCopy[] strOrigin输出:0x7a2550d0,strOrigin0123456
21:08:44.053 lbCopy[] aCopyStr输出:0x7a2550d0,strOrigin0123456
21:08:44.054 lbCopy[] strongStr输出:0x7a2550d0,strOrigin0123456
21:08:44.054 lbCopy[] weakStr输出:0x7a2550d0,strOrigin0123456
21:08:44.054 lbCopy[] strOrigin值内存引用计数3
21:08:44.054 lbCopy[] ------------------修改原值后------------------------
21:08:44.054 lbCopy[] strOrigin输出:0x8c1f8,aaa
21:08:44.054 lbCopy[] aCopyStr输出:0x7a2550d0,strOrigin0123456
21:08:44.054 lbCopy[] strongStr输出:0x7a2550d0,strOrigin0123456
21:08:44.055 lbCopy[] weakStr输出:0x7a2550d0,strOrigin0123456
21:08:44.055 lbCopy[] ------------------结论------------------------
21:08:44.055 lbCopy[] strOrigin值值为改变，但strOrigin和aCopyStr指针地址和指向都已经改变，说明不可变类型值不可被修改，重新初始化
21:08:44.059 lbCopy[] strOrigin输出:0x8c1f8,aaa
21:08:44.059 lbCopy[] aCopyStr输出:0x0,(null)
21:08:44.060 lbCopy[] strongStr输出:0x0,(null)
21:08:44.060 lbCopy[] weakStr输出:0x0,(null)
21:08:44.060 lbCopy[] ------------------结论------------------------
21:08:44.061 lbCopy[]当只有weakStr拥有C时，值依旧会被释放，同非容器可变变量
//以上是输出
此处我们将strOrigin拷贝给aCopyStr，strongStr，weakStr，然后输出他们的值地址，发现他们四个的值地址一样，且strOrigin值的引用计数为3。修改strOrigin和发现strOrigin值地址改变，其他三个值地址不变，将aCopyStr，strongStr设为nil后，发现weakStr随之nil。
综合上面现象NSString和NSMutableString（非容器可变变量）基本相同，除了copy，NSString为浅拷贝，NSMutableString是深拷贝。那么为什么NSString的copy是浅拷贝呢，也就是说为什么aCopyStr不自己开辟一个独立的内存出来呢。答案很简单，因为不可变量的值不会改变，既然都不会改变，所以没必要重新开辟一个内存出来让aCopyStr指向他，直接指向原来值位置就可以了。示意图如下
NSString拷贝示意图4
所以非容器不可变量除了copy其他特性同非容器可变变量，copy是浅拷贝
2.3不可变容器变量
典型对象NSArray。该对象实验自行实验。但结论在这里给出，其实不实验也可以大概知道概率
在不可变容器变量中，容器本身都是浅拷贝包括copy，同NSString，容器里面的数据都是浅拷贝，同NSMutableArray。
copy，strong，weak，assign的区别。
可变变量中，copy是重新开辟一个内存，strong，weak，assgin后三者不开辟内存，只是指针指向原来保存值的内存的位置，storng指向后会对该内存引用计数+1，而weak，assgin不会。weak，assgin会在引用保存值的内存引用计数为0的时候值为空，并且weak会将内存值设为nil，assign不会，assign在内存没有被重写前依旧可以输出，但一旦被重写将出现奔溃
不可变变量中，因为值本身不可被改变，copy没必要开辟出一块内存存放和原来内存一模一样的值，所以内存管理系统默认都是浅拷贝。其他和可变变量一样，如weak修饰的变量同样会在内存引用计数为0时变为nil。
容器本身遵守上面准则，但容器内部的每个值都是浅拷贝。
**综上所述，当创建property构造器创建变量value1的时候，使用copy，strong，weak，assign根据具体使用情况来决定。value1 = value2，如果你希望value1和value2的修改不会互相影响的就用用copy，反之用strong,weak,assign。如果你还希望原来值C(C是什么见示意图1)为nil的时候，你的变量不为nil就用strong,反之用weak和assign。weak和assign保证了不强引用某一块内存，如delegate我们就用weak表示，就是为了防止循环引用的产生。
另外，我们上面讨论的是类变量，直接创建局部变量默认是Strong修饰
补充：delegate为什么要用weak或者assign而不用strong
a创建对象b,b中有C类对象c，所以a对b有一个引用,b对c有一个引用，a.b引用计数分别为1，1。当c.delegate = b的时候，实则是对b有了一个引用，如果此时c的delegate用strong修饰则会对b的值内存引用计数+1，b引用计数为2。当a的生命周期结束，随之释放对b的引用，b的引用计数变为1，导致b不能释放，b不能释放又导致b对c的引用不能释放，c引用计数还是为1，这样就造成了b和c一直留在了内存中。
而要解决这个问题就是使用weak或者assign修饰delegate，这样虽然会有c仍然会对b有一个引用，但是引用是弱引用，当a生命周期结束的时候，b的引用计数变为0，b释放后随之c的引用消失，c引用计数变为0，释放。
不可变常量的特殊性
在2.2的讨论中如果你
1.字符串改成小于10长度的字符串
2.NSString*strOrigin = @"strOrigin0123456";
初始化NSString，你都会发现strOrigin值内存引用计数将发生异常，通常表现为引用计数特别大，具体可以看下这篇文章
错误之处希望能帮忙提出来，O(∩_∩)O谢谢了
儿子已经睡了，老婆在玩手机..
已经大半年没写代码了，技术没成熟却在年初开始和朋友开始摸索着自己弄了个小公司，摸索着做着产品，市场，运营这些工作，发现本来向往的工作还不如敲代码来的喜欢（这些话公司人肯定看不到）
趁着国庆长假好好修理了下简书上的一些文章，微微弥补下以前的误人子弟
我们公司运营的公众号【千手游戏】，现在由妹子运营着，有时间猿们可以捧个场
前言： 在iOS 开发中 我们经常用到 weak strong retain assign copy 属性的修饰，他们的区别本质上是1.是否开辟新的内存 2.是否对地址C有引用计数增加 的区别。 参考简书:http://www.jianshu.com/p/a29a0bdd5...
总结： 可变变量中，copy是重新开辟一个内存，strong，weak，assgin后三者不开辟内存，只是指针指向原来保存值的内存的位置，storng指向后会对该内存引用计数+1，而weak，assgin不会。weak，assgin会在引用保存值的内存引用计数为0的时候值为...
索引风格纠错题优化部分硬伤部分 什么情况使用 weak 关键字，相比 assign 有什么不同？怎么用 copy 关键字？这个写法会出什么问题： @property (copy) NSMutableArray *如何让自己的类用 copy 修饰符？如何重写带 c...
//联系人:石虎QQ: 昵称:嗡嘛呢叭咪哄 OC关键字:copy,assign,strong,retain,weak,readonly,readwrite，nonatomic，atomic，unsafe_unretained的使用与区别 一、关键字的概念...
__block和__weak修饰符的区别其实是挺明显的：1.__block不管是ARC还是MRC模式下都可以使用，可以修饰对象，还可以修饰基本数据类型。2.__weak只能在ARC模式下使用，也只能修饰对象(NSString)，不能修饰基本数据类型(int)。3.__blo...
今天这种悲伤的气氛中让我想到一段话“江湖险恶，人心难测，昨天我还穿金戴银，今天成为流浪狗，昨天我还妻妾成群，今天成为光棍”而我昨天幸福美满，今天有“家”不能回。
python 中如果没有指定编码方式的话，那么默认支持的是ASCII码，如果出现中文则会报错，即便中文是注释也不行 官方网站关于 coding 的处理方法 具体的写法可以参考官方的写法 下面两种常见的方法 # -*- coding: utf-8 -*- 此种方法是官方推荐的...
今天王茹老师针对图书的出版方式和变现进行了专业分享，趁热回顾，梳理如下： 一、出书训练营&写作训练营 写作是一种修行，而出书是从量到质的蜕变，是将分散的、零碎的知识，进行系统的梳理，形成体系化的结果输出。此外，个人感觉，写作的受众是自己，只需对自己有交待；而出书，面对的是读...
按：提起巩泽惠，忍不住想笑。她不属于学霸群体，但绝对可以划归古灵精怪的小妖女一族。运动达人，泳池资深小鱼儿，逗比班长，情商极高，笑点多多……喜欢读你的随笔，就是那份真和特别吧，令人忍俊不禁而无可替代。
感谢相伴的美好 我有很深的恋物情节。