iOS之属性修饰符 retain、strong和copy区别测试
时不时会有点迷惑属性修饰符retain、strong、copy三者之间的区别，还是把测试过程记录下来好一点！
2、给retain、strong、copy修饰的字符串属性赋值指针变化测试例子
3、字符串调用copy、mutableCopy方法给字符串赋值指针变化例子
一、属性修饰符retain、strong、copy修饰字符串测试
先看代码，创建一个Person类，定义属性
#import <Foundation/Foundation.h> @interface Person : NSObject @property (nonatomic, retain) NSString *strRetain;
@property (nonatomic, strong) NSString *strStrong;
@property (nonatomic, copy) NSString *strCopy;
@property (nonatomic, retain) NSMutableString *strMutableRetain;
@property (nonatomic, strong) NSMutableString *strMutableStrong;
@property (nonatomic, copy) NSMutableString *strMutableCopy; @end
测试代码：
Person *per = [[Person alloc] init];
NSString *name = @"原XM";
[per setStrRetain:name];
[per setStrStrong:name];
per.strCopy = name; NSMutableString *name2 = [[NSMutableString alloc] initWithString:@"原XM2"];
per.strMutableRetain = name2;
per.strMutableStrong = name2;
per.strMutableCopy = name2; NSLog(@"------ 改变之前打印 ------");
NSLog(@"per.strRetain: %@, ", per.strRetain);
NSLog(@"per.strStrong: %@", per.strStrong);
NSLog(@"per.strCopy: %@", per.strCopy);
NSLog(@"per.strMutableRetain: %@", per.strMutableRetain);
NSLog(@"per.strMutableStrong: %@", per.strMutableStrong);
NSLog(@"per.strMutableCopy: %@", per.strMutableCopy); name = @"新XM";
[name2 appendString:@"新XM2"]; NSLog(@"------- 改变之后打印 -------");
NSLog(@"per.strRetain: %@", per.strRetain);
NSLog(@"per.strStrong: %@", per.strStrong);
NSLog(@"per.strCopy: %@", per.strCopy);
NSLog(@"per.strMutableRetain: %@", per.strMutableRetain);
NSLog(@"per.strMutableStrong: %@", per.strMutableStrong);
NSLog(@"per.strMutableCopy: %@", per.strMutableCopy);
打印日志：
------ 改变之前打印 ------
per.strRetain: 原XM,
per.strStrong: 原XM
per.strCopy: 原XM
per.strMutableRetain: 原XM2
per.strMutableStrong: 原XM2
per.strMutableCopy: 原XM2
------- 改变之后打印 -------
per.strRetain: 原XM
per.strStrong: 原XM
per.strCopy: 原XM
per.strMutableRetain: 原XM2新XM2
per.strMutableStrong: 原XM2新XM2
per.strMutableCopy: 原XM2
结论：
1、对于不可变对象来说：retain、strong、copy三者的作用是一样的，即当引用的原对象值改变后，其他引用该对象的属性值不会受影响，还是保持原来的值；
2、对于可变对象来说：retain、strong和copy的作用就有区别了，使用retain、strong修饰的属性，当引用的原对象值改变后，其他引用该对象的属性值会一起跟着变化，而copy修饰的属性的值还是保持原样。copy的作用主要也是体现在这里： 让属性值不会随着原引用对象的值改变而改变；
3、retain和strong的区别：作用是一样的，只是写法上的区别。在非arc机制时，是用retain关键字修饰；在arc机制后，一般都用strong关键字来代替retain了
4、根本原因是：给字符串属性赋值不可变字符串，retain、strong、copy修饰的可变和不可变字符串属性都是指针拷贝；
给字符串属性赋值可变字符串，retain、strong修饰的可变和不可变字符串属性是指针拷贝，而copy修饰的可变和不可变字符串属性都是内容拷贝。
(说明一下：第一种情况，给字符串属性赋值不可变字符串，虽然retain、strong、copy修饰的属性都是指针拷贝，但是因为源数据是不可变字符串，导致源数据值改变后，相应的就是另外一个指针地址了，但是这些属性还是原来的指针，所以值也是原来的值不会改变；
第二种情况，给字符串属性赋值可变字符串，retain、strong修饰的属性是指针拷贝，所以源可变字符串值改变后，指针没变，则retain、strong修饰的属性指针与源字符串一样，所以值也跟着变化；而copy修饰的字符串属性是内容拷贝，源字符串的值改变和属性已经没有关系了，因而不会引起属性值改变。
所以，我们如果从效果来看的话，想要源字符串值的改变不引起属性字符串值的改变，只有当源字符串是可变字符串时，属性才需要用copy修饰，其他情况使用strong、retain修饰效果是一样的，虽然是指针拷贝，但是源字符串值的改变不会引起属性字符串值的改变。当然我们还是要理解他们的区别才是王道。所以一般字符串属性都是用copy来修饰，靠谱的用法！
)
指针变化见如下代码
------ 再次打印，这次把指针的变化都打印出来，一目了然，彻底明白 ------
NSString *str1 = @"oneone壹亿一";
Person *obj = [[Person alloc] init];
obj.strStrong = str1; //指针拷贝
obj.strRetain = str1; //指针拷贝
obj.strCopy = str1; //指针拷贝
obj.strMutableStrong = str1; //指针拷贝
obj.strMutableRetain = str1; //指针拷贝
obj.strMutableCopy = str1; //指针拷贝
NSLog(@"指针1：%p, %p, %p, %p, %p, %p, %p", str1, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
NSLog(@"值1：%@, %@, %@, %@, %@, %@, %@", str1, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
/*
指针1：0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30
值1：oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一
*/ str1 = @"twotwo我";
NSLog(@"指针2：%p, %p, %p, %p, %p, %p, %p", str1, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
NSLog(@"值2：%@, %@, %@, %@, %@, %@, %@", str1, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
/*
指针2：0x10c861e90, 0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30, 0x10c861e30
值2：twotwo我, oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一, oneone壹亿一
*/ NSString *str2 = [[NSString alloc] initWithFormat:@"three哈%d", ];
obj.strStrong = str2; //指针拷贝
obj.strRetain = str2; //指针拷贝
obj.strCopy = str2; //指针拷贝
obj.strMutableStrong = str2; //指针拷贝
obj.strMutableRetain = str2; //指针拷贝
obj.strMutableCopy = str2; //指针拷贝
NSLog(@"指针3：%p, %p, %p, %p, %p, %p, %p", str2, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
NSLog(@"值3：%@, %@, %@, %@, %@, %@, %@", str2, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
/*
指针3：0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650
值3：three哈8, three哈8, three哈8, three哈8, three哈8, three哈8, three哈8
*/ str2 = @"four啊";
NSLog(@"指针4：%p, %p, %p, %p, %p, %p, %p", str2, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
NSLog(@"值4：%@, %@, %@, %@, %@, %@, %@", str2, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
/*
指针4：0x10c861f50, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650, 0x7fb9f9e04650
值4：four啊, three哈8, three哈8, three哈8, three哈8, three哈8, three哈8
*/ NSLog(@" ---- start NSMutableString -------");
NSMutableString *str3 = [[NSMutableString alloc] initWithString:@"five神"];
obj.strStrong = str3; //指针拷贝
obj.strRetain = str3; //指针拷贝
obj.strCopy = str3; //内容拷贝
obj.strMutableStrong = str3; //指针拷贝
obj.strMutableRetain = str3; //指针拷贝
obj.strMutableCopy = str3; //内容拷贝
/*
.语法和setter方法设置值的效果是一样的
[obj setStrStrong: str3];
[obj setStrRetain: str3];
[obj setStrCopy: str3];
[obj setStrMutableStrong: str3];
[obj setStrMutableRetain: str3];
[obj setStrMutableCopy: str3];
*/
NSLog(@"指针5：%p, %p, %p, %p, %p, %p, %p", str3, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
NSLog(@"值5：%@, %@, %@, %@, %@, %@, %@", str3, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
/*
指针5：0x7fb9f9d9b920, 0x7fb9f9d9b920, 0x7fb9f9d9b920, 0x7fb9f9d9b6c0, 0x7fb9f9d9b920, 0x7fb9f9d9b920, 0x7fb9f9d0b930
值5：five神, five神, five神, five神, five神, five神, five神
*/ [str3 appendString:@"明天"];
NSLog(@"指针6：%p, %p, %p, %p, %p, %p, %p", str3, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
NSLog(@"值6：%@, %@, %@, %@, %@, %@, %@", str3, obj.strStrong, obj.strRetain, obj.strCopy, obj.strMutableStrong, obj.strMutableRetain, obj.strMutableCopy);
/*
指针6：0x7fb9f9d9b920, 0x7fb9f9d9b920, 0x7fb9f9d9b920, 0x7fb9f9d9b6c0, 0x7fb9f9d9b920, 0x7fb9f9d9b920, 0x7fb9f9d0b930
值6：five神明天, five神明天, five神明天, five神, five神明天, five神明天, five神
*/
再次描述下结论：
给字符串属性赋值不可变字符串，retain、strong、copy修饰的可变和不可变字符串属性都是指针拷贝；
给字符串属性赋值可变字符串，retain、strong修饰的可变和不可变字符串属性是指针拷贝，而copy修饰的可变和不可变字符串属性都是内容拷贝。
关键变化，截图标识一下：
--------------- 一 end ---------------
二、字符串调用copy、mutableCopy方法给字符串赋值
看看字符串调用copy和mutableCopy方法给字符串赋值，还有给属性修饰符修饰的字符串属性赋值指针变化
先看代码1：
//不可变字符串
NSString *str = @"aa啊";
NSString *str1 = [str copy]; //指针拷贝
NSString *str2 = [str mutableCopy]; //内容拷贝
NSMutableString *str3 = [str copy]; //指针拷贝
NSMutableString *str4 = [str mutableCopy]; //内容拷贝 NSLog(@"指针1：%p, %p, %p, %p, %p", str, str1, str2, str3, str4);
/*
指针1：0x1041093f0, 0x1041093f0, 0x7f951840b6e0, 0x1041093f0, 0x7f951840dfe0
*/ //可变字符串
NSMutableString *str5 = [NSMutableString stringWithString:@"bb吧"];
str1 = [str5 copy]; //内容拷贝
str2 = [str5 mutableCopy]; //内容拷贝
str3 = [str5 copy]; //内容拷贝
str4 = [str5 mutableCopy]; //内容拷贝 NSLog(@"指针2：%p, %p, %p, %p, %p", str5, str1, str2, str3, str4);
NSLog(@"值2：%@, %@, %@, %@, %@", str5, str1, str2, str3, str4);
/*
指针2：0x7f9518410af0, 0x7f9518435840, 0x7f9518416390, 0x7f9518403a00, 0x7f951840b6e0
值2：bb吧, bb吧, bb吧, bb吧, bb吧
*/ [str5 appendString:@"大大"];
NSLog(@"指针3：%p, %p, %p, %p, %p", str5, str1, str2, str3, str4);
NSLog(@"值3：%@, %@, %@, %@, %@", str5, str1, str2, str3, str4);
/*
指针3：0x7f9518410af0, 0x7f9518435840, 0x7f9518416390, 0x7f9518403a00, 0x7f951840b6e0
值3：bb吧大大, bb吧, bb吧, bb吧, bb吧
*/
结论：1）、不可变字符串使用copy方法赋值给其他可变或不可变字符串，都是指针拷贝；
2）、不可变字符串使用mutableCopy方法赋值给可变或不可变字符串，和可变字符串使用copy方法或者mutableCopy方法赋值给其他可变或不可变字符串，都是内容拷贝
再看代码2：
Person *obj = [[Person alloc] init];
NSString *str = @"y壹"; //不可变字符串调用copy方法，全部指针拷贝
obj.strStrong = [str copy];
obj.strCopy = [str copy];
obj.strMutableStrong = [str copy];
obj.strMutableCopy = [str copy];
NSLog(@"指针1：%p, %p, %p, %p, %p", str, obj.strStrong, obj.strCopy, obj.strMutableStrong, obj.strMutableCopy);
//指针1：0x101be34f0, 0x101be34f0, 0x101be34f0, 0x101be34f0, 0x101be34f0 //不可变字符串调用mutableCopy方法，全部内容拷贝
str = @"e二";
obj.strStrong = [str mutableCopy];
obj.strCopy = [str mutableCopy];
obj.strMutableStrong = [str mutableCopy];
obj.strMutableCopy = [str mutableCopy];
NSLog(@"指针2：%p, %p, %p, %p, %p", str, obj.strStrong, obj.strCopy, obj.strMutableStrong, obj.strMutableCopy);
//指针2：0x101be3510, 0x7ff939498790, 0x7ff9394a2020, 0x7ff9394970c0, 0x7ff939405d40 //可变字符串调用copy方法，全部内容拷贝
NSMutableString *str2 = [NSMutableString stringWithString:@"h叁"];
obj.strStrong = [str2 copy];
obj.strCopy = [str2 copy];
obj.strMutableStrong = [str2 copy];
obj.strMutableCopy = [str2 copy];
NSLog(@"指针3：%p, %p, %p, %p, %p", str2, obj.strStrong, obj.strCopy, obj.strMutableStrong, obj.strMutableCopy);
//指针3：0x7ff93951f540, 0x7ff93954a100, 0x7ff9395288c0, 0x7ff939516ca0, 0x7ff939548db0 //可变字符串调用mutableCopy方法，全部内容拷贝
[str2 appendString:@"叁2"];
obj.strStrong = [str2 mutableCopy];
obj.strCopy = [str2 mutableCopy];
obj.strMutableStrong = [str2 mutableCopy];
obj.strMutableCopy = [str2 mutableCopy];
NSLog(@"指针4：%p, %p, %p, %p, %p", str2, obj.strStrong, obj.strCopy, obj.strMutableStrong, obj.strMutableCopy);
//指针4：0x7ff93951f540, 0x7ff93951f320, 0x7ff93954a100, 0x7ff9395627b0, 0x7ff939516ca0
结论：1）、不可变字符串调用copy给strong, copy修饰的属性赋值，都是指针拷贝；
2）、不可变字符串调用mutableCopy, 和可变字符串调用copy，和可变字符串调用mutableCopy方法给strong、copy修饰的属性赋值，都是内容拷贝
所以说属性修饰符copy不一定代表着深拷贝，碰上数据源为不可变数据则是浅拷贝（指针拷贝），碰上数据源是可变数据则是深拷贝（内容拷贝）；
NSObject的方法copy也不一定代表着浅拷贝，碰上数据源为不可变数据则是浅拷贝，碰上数据源是可变数据则是深拷贝；
NSObject的方法mutableCopy不管数据源是不可变还是可变，都是深拷贝；
这以上几个结论适用字符串，也适用下面的数组测试！
---------------- 二 end --------------
三、给修饰符strong、copy修饰的数组赋值测试
先创建一个有数组属性的模型类TestArr :
@interface TestArr : NSObject //测试数组的copy和strong属性
@property (nonatomic, strong) NSArray *arrStrong;
@property (nonatomic, copy) NSArray *arrCopy; @property (nonatomic, strong) NSMutableArray *arrMutableStrong;
@property (nonatomic, copy) NSMutableArray *arrMutableCopy; @end
1、数组直接赋值给修饰符strong、copy修饰的属性
NSArray *arr1 = [NSArray arrayWithObjects:@"twotwo2", nil];
TestArr *arrObj = [[TestArr alloc] init];
// arrObj.arrStrong = arr1; //指针拷贝
// arrObj.arrCopy = arr1; //指针拷贝
// arrObj.arrMutableStrong = arr1; //指针拷贝
// arrObj.arrMutableCopy = arr1; //指针拷贝
//.语法和setter方法设置值效果一样
[arrObj setArrStrong:arr1];
[arrObj setArrCopy:arr1];
[arrObj setArrMutableStrong:arr1];
[arrObj setArrMutableCopy:arr1]; NSLog(@"指针9：%p, %p, %p, %p, %p", arr1, arrObj.arrStrong, arrObj.arrCopy, arrObj.arrMutableStrong, arrObj.arrMutableCopy);
NSLog(@"值9：%@, %@, %@, %@, %@", arr1[], arrObj.arrStrong[], arrObj.arrCopy[], arrObj.arrMutableStrong[], arrObj.arrMutableCopy[]);
/*
指针9：0x7fd8e8e04870, 0x7fd8e8e04870, 0x7fd8e8e04870, 0x7fd8e8e04870, 0x7fd8e8e04870
值9：twotwo2, twotwo2, twotwo2, twotwo2, twotwo2
*/ arr1 = @[@"TEST哈"];
NSLog(@"指针10：%p, %p, %p, %p, %p", arr1, arrObj.arrStrong, arrObj.arrCopy, arrObj.arrMutableStrong, arrObj.arrMutableCopy);
NSLog(@"值10：%@, %@, %@, %@, %@", arr1[], arrObj.arrStrong[], arrObj.arrCopy[], arrObj.arrMutableStrong[], arrObj.arrMutableCopy[]);
/*
指针10：0x7fd8e8e0cda0, 0x7fd8e8e04870, 0x7fd8e8e04870, 0x7fd8e8e04870, 0x7fd8e8e04870
值10：TEST哈, twotwo2, twotwo2, twotwo2, twotwo2
*/ NSMutableArray *arr6 = [NSMutableArray arrayWithObjects:@"风清扬", nil];
//赋值可变数组
arrObj.arrStrong = arr6; //指针拷贝
arrObj.arrCopy = arr6; //内容拷贝
arrObj.arrMutableStrong = arr6; //指针拷贝
arrObj.arrMutableCopy = arr6; //内容拷贝 NSLog(@"指针11：%p, %p, %p, %p, %p", arr6, arrObj.arrStrong, arrObj.arrCopy, arrObj.arrMutableStrong, arrObj.arrMutableCopy);
NSLog(@"值11：%@, %@, %@, %@, %@", arr6[], arrObj.arrStrong[], arrObj.arrCopy[], arrObj.arrMutableStrong[], arrObj.arrMutableCopy[]);
/*
指针11：0x7fd8e8f1cce0, 0x7fd8e8f1cce0, 0x7fd8e8c14480, 0x7fd8e8f1cce0, 0x7fd8e8c14f00
值11：风清扬, 风清扬, 风清扬, 风清扬, 风清扬
*/ arr6[] = @"哈宝";
NSLog(@"指针12：%p, %p, %p, %p, %p", arr6, arrObj.arrStrong, arrObj.arrCopy, arrObj.arrMutableStrong, arrObj.arrMutableCopy);
NSLog(@"值12：%@, %@, %@, %@, %@", arr6[], arrObj.arrStrong[], arrObj.arrCopy[], arrObj.arrMutableStrong[], arrObj.arrMutableCopy[]);
/*
指针12：0x7fd8e8f1cce0, 0x7fd8e8f1cce0, 0x7fd8e8c14480, 0x7fd8e8f1cce0, 0x7fd8e8c14f00
值12：哈宝, 哈宝, 风清扬, 哈宝, 风清扬
*/
结论：1)、不可变数组直接赋值给strong、copy修饰的数组属性，都是指针拷贝
2)、可变数组直接赋值给strong修饰的可变或不可变数组属性，都是指针拷贝；赋值给copy修饰的可变或不可变数组属性，都是内容拷贝
效果和字符串属性的效果是一样的！
2、数组调用copy、mutableCopy方法给数组赋值
NSArray *arr1 = [[NSArray alloc] initWithObjects:@"onone", nil];
NSArray *arr2 = [[NSArray alloc] initWithObjects:@"onone", nil];
NSArray *arr3 = [[NSArray alloc] initWithObjects:@"onone", nil];
NSMutableArray *arr4 = [[NSMutableArray alloc] initWithObjects:@"onone", nil];
NSMutableArray *arr5 = [[NSMutableArray alloc] initWithObjects:@"onone", nil];
NSLog(@"指针0：%p, %p, %p, %p, %p", arr1, arr2, arr3, arr4, arr5);
/*
指针0：0x7fd8e8db25b0, 0x7fd8e8d06540, 0x7fd8e8d132b0, 0x7fd8e8db1bc0, 0x7fd8e8db2620
*/
arr2 = [arr1 copy]; //指针拷贝
arr3 = [arr1 mutableCopy]; //内容拷贝
arr4 = [arr1 copy]; //指针拷贝
arr5 = [arr1 mutableCopy]; //内容拷贝
NSLog(@"指针1：%p, %p, %p, %p, %p", arr1, arr2, arr3, arr4, arr5);
NSLog(@"值1：%@, %@, %@, %@, %@", arr1[], arr2[], arr3[], arr4[], arr5[]);
/*
指针1：0x7fd8e8db25b0, 0x7fd8e8db25b0, 0x7fd8e8daff70, 0x7fd8e8db25b0, 0x7fd8e8db1bc0
值1：onone, onone, onone, onone, onone
*/
arr1 = @[@"twotwo"];
NSLog(@"指针2：%p, %p, %p, %p, %p", arr1, arr2, arr3, arr4, arr5);
NSLog(@"值2：%@, %@, %@, %@, %@", arr1[], arr2[], arr3[], arr4[], arr5[]);
/*
指针2：0x7fd8e8f036e0, 0x7fd8e8db25b0, 0x7fd8e8daff70, 0x7fd8e8db25b0, 0x7fd8e8db1bc0
值2：twotwo, onone, onone, onone, onone
*/
NSMutableArray *arr6 = [NSMutableArray arrayWithObjects:@"three", nil];
arr2 = [arr6 copy]; //内容拷贝
arr3 = [arr6 mutableCopy]; //内容拷贝
arr4 = [arr6 copy]; //内容拷贝
arr5 = [arr6 mutableCopy]; //内容拷贝
NSLog(@"指针3：%p, %p, %p, %p, %p", arr6, arr2, arr3, arr4, arr5);
NSLog(@"值3：%@, %@, %@, %@, %@", arr6[], arr2[], arr3[], arr4[], arr5[]);
/*
指针3：0x7fd8e8f1cce0, 0x7fd8e8f06d90, 0x7fd8e8f0c7c0, 0x7fd8e8f0c7f0, 0x7fd8e8f03150
值3：three, three, three, three, three
*/
arr6[] = @"大侠";
NSLog(@"指针4：%p, %p, %p, %p, %p", arr6, arr2, arr3, arr4, arr5);
NSLog(@"值4：%@, %@, %@, %@, %@", arr6[], arr2[], arr3[], arr4[], arr5[]);
/*
指针4：0x7fd8e8f1cce0, 0x7fd8e8f06d90, 0x7fd8e8f0c7c0, 0x7fd8e8f0c7f0, 0x7fd8e8f03150
值4：大侠, three, three, three, three
*/
结论：1)、不可变数组调用copy赋值给可变数组或不可变数组都是指针拷贝；不可变数组调用mutableCopy赋值给可变数组或不可变数组都是内容拷贝
2)、可变数组调用copy或mutableCopy赋值给可变数组或不可变数组，都是内容拷贝
效果和字符串也是一样！
3、数组调用copy、mutableCopy方法给数组属性赋值
TestArr *obj = [[TestArr alloc] init];
NSArray *arr = [NSArray arrayWithObjects:@"one哦", nil];
//都是指针拷贝
obj.arrStrong = [arr copy];
obj.arrCopy = [arr copy];
obj.arrMutableStrong = [arr copy];
obj.arrMutableCopy = [arr copy];
NSLog(@"指针1：%p, %p, %p, %p, %p", arr, obj.arrStrong, obj.arrCopy, obj.arrMutableStrong, obj.arrMutableCopy);
NSLog(@"值1：%@, %@, %@, %@, %@", arr[], obj.arrStrong[], obj.arrCopy[], obj.arrMutableStrong[], obj.arrMutableCopy[]);
/*
指针1：0x7fbf18c2a2b0, 0x7fbf18c2a2b0, 0x7fbf18c2a2b0, 0x7fbf18c2a2b0, 0x7fbf18c2a2b0
值1：one哦, one哦, one哦, one哦, one哦
*/ //都是内容拷贝
arr = [NSArray arrayWithObjects:@"two他", nil];
obj.arrStrong = [arr mutableCopy];
obj.arrCopy = [arr mutableCopy];
obj.arrMutableStrong = [arr mutableCopy];
obj.arrMutableCopy = [arr mutableCopy];
NSLog(@"指针2：%p, %p, %p, %p, %p", arr, obj.arrStrong, obj.arrCopy, obj.arrMutableStrong, obj.arrMutableCopy);
NSLog(@"值2：%@, %@, %@, %@, %@", arr[], obj.arrStrong[], obj.arrCopy[], obj.arrMutableStrong[], obj.arrMutableCopy[]);
/*
指针2：0x7fbf18f0ec40, 0x7fbf18d09e80, 0x7fbf18d36540, 0x7fbf18d09eb0, 0x7fbf18d014b0
值2：two他, two他, two他, two他, two他
*/ //可变数组
//都是内容拷贝
NSMutableArray *arr2 = [NSMutableArray arrayWithObjects:@"th叁", nil];
obj.arrStrong = [arr2 copy];
obj.arrCopy = [arr2 copy];
obj.arrMutableStrong = [arr2 copy];
obj.arrMutableCopy = [arr2 copy];
NSLog(@"指针3：%p, %p, %p, %p, %p", arr2, obj.arrStrong, obj.arrCopy, obj.arrMutableStrong, obj.arrMutableCopy);
NSLog(@"值3：%@, %@, %@, %@, %@", arr2[], obj.arrStrong[], obj.arrCopy[], obj.arrMutableStrong[], obj.arrMutableCopy[]);
/*
指针3：0x7fbf18f6c420, 0x7fbf18f693a0, 0x7fbf18f00500, 0x7fbf18f63c60, 0x7fbf18f01660
值3：th叁, th叁, th叁, th叁, th叁
*/ arr2[] = @"司ss";
NSLog(@"指针3_2：%p, %p, %p, %p, %p", arr2, obj.arrStrong, obj.arrCopy, obj.arrMutableStrong, obj.arrMutableCopy);
NSLog(@"值3_2：%@, %@, %@, %@, %@", arr2[], obj.arrStrong[], obj.arrCopy[], obj.arrMutableStrong[], obj.arrMutableCopy[]);
/*
值3_2：司ss, th叁, th叁, th叁, th叁
*/ //都是内容拷贝
obj.arrStrong = [arr2 mutableCopy];
obj.arrCopy = [arr2 mutableCopy];
obj.arrMutableStrong = [arr2 mutableCopy];
obj.arrMutableCopy = [arr2 mutableCopy];
NSLog(@"指针4：%p, %p, %p, %p, %p", arr2, obj.arrStrong, obj.arrCopy, obj.arrMutableStrong, obj.arrMutableCopy);
NSLog(@"值4：%@, %@, %@, %@, %@", arr2[], obj.arrStrong[], obj.arrCopy[], obj.arrMutableStrong[], obj.arrMutableCopy[]);
/*
指针4：0x7fbf18f6c420, 0x7fbf18f620e0, 0x7fbf18f693a0, 0x7fbf18f6c9a0, 0x7fbf18d014b0
值4：司ss, 司ss, 司ss, 司ss, 司ss
*/ arr2[]=@"Ni打野";
NSLog(@"指针5：%p, %p, %p, %p, %p", arr2, obj.arrStrong, obj.arrCopy, obj.arrMutableStrong, obj.arrMutableCopy);
NSLog(@"值5：%@, %@, %@, %@, %@", arr2[], obj.arrStrong[], obj.arrCopy[], obj.arrMutableStrong[], obj.arrMutableCopy[]);
/*
值5：Ni打野, 司ss, 司ss, 司ss, 司ss
*/
结论：1）、不可变数组调用copy给strong、copy修饰的数组属性赋值，都是指针拷贝；
2）、 不可变数组调用mutableCopy, 和可变数组调用copy, 和可变数组调用mutableCopy方法给strong、copy修饰的数组属性赋值，都是内容拷贝
和字符串效果也是一样
--------------- 三 end ---------------
原文链接：http://www.cnblogs.com/tandaxia/p/4475410.html
iOS之属性修饰符 retain、strong和copy区别测试的更多相关文章
- iOS 属性修饰符记录 --不定时更新
重新审视了一下OC在属性修饰符,特意记录一下来.以后不定时更新 > retain:只有在非ARC下才会有效,所有如果在ARC下使用了retain修饰也白搭 如以下的data属性用retain修饰 ...
- 关于@property()的那些属性及ARC简介【nonatomic,atomic,assign,retain,strong,weak,copy。】
@property()常用的属性有:nonatomic,atomic,assign,retain,strong,weak,copy. 其中atomic和nonatomic用来决定编译器生成的gette ...
- 参数修饰符ref,out ,params的区别
参数修饰符ref,out ,params的区别 C#中有三个关键字-ref,out ,params,可是这三个之间的区别你都明白了吗? 那么我们就来认识一下参数修饰符ref,out ,params吧, ...
- iOS的属性声明：retain和strong的区别
声明属性时用strong或者retain效果是一样的(貌似更多开发者更倾向于用strong).不过在声明Block时,使用strong和retain会有截然不同的效果.strong会等于copy,而r ...
- UE4C++定义属性修饰符总结
1.BlueprintAssignable 暴露该属性来在蓝图中进行赋值,用于绑定多播委托 2.BlueprintCallable 用于从蓝图中调用C++原生函数 3.BlueprintReadO ...
- iOS学习——属性引用self.xx与_xx的区别
在iOS开发过程中,我们用@proprety声明一个属性后,在代码中我们可以用self.xx与_xx来获取到这个属性.但是一直有一个疑惑,那就是这两个之间有什么区别呢?最初我一直觉得这两个之间没什么区 ...
- IOS 类的属性修饰符atomic
在声明一个类的属性时,默认这个属性会被修饰atomic,意思是原子性访问的. nonatomic和atomic修饰的属性,在自己没有重写setter和getter的时候才会发生作用,其主要的作用可以理 ...
- ios学习路线—Objective-C(属性修饰符)
readonly: 此标记说明属性是只读的,默认的标记是读写,如果你指定了只读,在@implementation中只需要一个读取器.或者如果你使用@synthesize关键字,也是有读取器方法被解析. ...
- iOS 实例变量修饰符
@public 可以在其他类中访问被@public修饰的成员变量 可以在本类中访问被@public修饰的成员变量 可以在子类中访问fl中被@public修饰的成员变量 @private 不可以在其他类 ...
随机推荐
- [New Portal]Windows Azure Virtual Machine (15) 在本地制作数据文件VHD并上传至Azure(2)
<Windows Azure Platform 系列文章目录> 在上一章内容里,我们已经将包含有OFFICE2013 ISO安装文件的VHD上传至Azure Blob Storage中了. ...
- Elasticsearch——分词器对String的作用
更多内容参考:Elasticsearch学习总结 关于String类型--分词与不分词 在Elasticsearch中String是最基本的数据类型,如果不是数字或者标准格式的日期等这种很明显的类型, ...
- C# 模拟提交 Form表单的数据
用 HttpWebRequest Post方法模拟提交Form表单数据时,需要设置 ContentType 为 "application/x-www-form-urlencoded" ...
- GitHub for Windows 2.0使用教程
Git是目前最先进的分布式版本控制系统,作为一个程序员,我们需要掌握其用法. 一:下载GitHub for Windows 2.0 二:安装GitHub 下载之后点击进行安装过程,安装之后桌面上会有 ...
- java servlet手机app访问接口(一)数据加密传输验证
前面几篇关于servlet的随笔,算是拉通了 servlet的简单使用流程,接下去的文章将主要围绕手机APP访问接口这块出发续写,md5加密传输--->短信验证--->手机推送---> ...
- 通过“回文字算法”复习C++语言。
一.什么是回文字 给定一个字符串,从前往后读和从后往前读,字符串序列不变.例如,河北省农村信用社的客服电话是“96369”,无论从后往前读,还是从前后往后读,各个字符出现的位置不变. 二.功能实现 ( ...
- 关于线上的bug什么时候修复的思考
这里系统专门指的是那种用户量大的系统,比如有几百万或者上千万的注册会员.因为小系统因为用户量少,不存在这种思考,考虑有时候是多余的.另外还有内部系统,给自己公司内部人员使用的,即便是出现了问题,也不会 ...
- 左求值表达式，堆栈，调试陷阱与ORM查询语言的设计
1,表达式的求值顺序与堆栈结构 “表达式” 是程序语言一个很重要的术语,也是大家天天写的程序中很常见的东西,但是表达式的求值顺序一定是从左到右么? C/C++语言中没有明确规定表达式的运算顺序(从左到 ...
- java集合-HashTable
概述 和 HashMap 一样,Hashtable 也是一个散列表,它存储的内容是键值对. Hashtable 在 Java 中的定义为: public class Hashtable<K,V& ...
- 使用Sublime Text作为Markdown编辑器
Sublime Text 3作为一个优秀的文本编辑器,拥有很多的扩展插件.我们可以利用这些插件为Sublime Text 增加扩展的功能,在这里我们借助两个插件来将Sublime Text 3变成一个 ...