【iOS】copy&strong原理+深浅拷贝+完全拷贝
Copy&Strong原理Copy探究
在答复copy的各种问题前，我们需要先了解我们为什么要使用copy。
[*]
[*]拷贝的目标 ： 产生一个副本对象，跟源对象互不影响
[*]修改了源对象，不会影响副本对象
[*]修改了副本对象，不会影响源对象
[*]
[*]iOS提供了2个拷贝方法
[*]
[*]copy，不可变拷贝，产生不可变副本
[*]
[*]mutableCopy， 可变拷贝，产生可变副本
[*]
[*]深拷贝和浅拷贝
[*]
[*]深拷贝 ： 内容拷贝，产生新的对象
[*]
[*]浅拷贝 ： 指针拷贝， 没有产生新的对象
下面是是6个test，分别是 可变/不可变 的 字符串/数组/字典 对应的 copy和mutableCopy操纵。
复习的时候都不用看，直接看结论，想清晰都很简单
test1
对不可变字符串进行copy&mutableCopy操纵
void test1()
{
NSString *str1 = ;
NSString *str2 = ; // 返回的是NSString
NSMutableString *str3 = ; // 返回的是NSMutableString
NSLog(@"%p %p %p", str1, str2, str3);
}
https://i-blog.csdnimg.cn/direct/d4d0aae51f8941b5ba2976295330e008.png
我们根据打印的地址可以看出不可变字符串在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象
test2
对可变字符串进行copy&mutableCopy操纵
void test2()
{
NSMutableString *str1 = [ initWithFormat:@"test"]; // 1
NSString *str2 = ; // 深拷贝
NSMutableString *str3 = ; // 深拷贝
NSLog(@"%p %p %p", str1, str2, str3);
}
https://i-blog.csdnimg.cn/direct/e4ea83b230ce42d3827e458527b49855.png
我们根据打印的地址可以看出对于可变字符串不论是copy还是mutableCopy都是深拷贝
test3
对不可变数组进行copy&mutableCopy操纵
void test3()
{
NSArray *array1 = [ initWithObjects:@"a", @"b", nil];
NSArray *array2 = ; // 浅拷贝
NSMutableArray *array3 = ; // 深拷贝
NSLog(@"%p %p %p", array1, array2, array3);
}
https://i-blog.csdnimg.cn/direct/2f172698e72244f48320cdb34a4fcb2a.png
我们根据打印的地址可以看出不可变数组在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象
test4
对可变数组进行copy&mutableCopy操纵
void test4()
{
NSMutableArray *array1 = [ initWithObjects:@"a", @"b", nil];
NSArray *array2 = ; // 深拷贝
NSMutableArray *array3 = ; // 深拷贝
NSLog(@"%p %p %p", array1, array2, array3);
}
https://i-blog.csdnimg.cn/direct/af8bf758c1a940038c092f8bf6faa38c.png
我们根据打印的地址可以看出对于可变数组不论是copy还是mutableCopy都是深拷贝
test5
对不可变字典进行copy&mutableCopy操纵
void test5()
{
NSDictionary *dict1 = [ initWithObjectsAndKeys:@"jack", @"name", nil];
NSDictionary *dict2 = ; // 浅拷贝
NSMutableDictionary *dict3 = ; // 深拷贝
NSLog(@"%p %p %p", dict1, dict2, dict3);
}
https://i-blog.csdnimg.cn/direct/ff04e42c7199447896ed106401e6d656.png
我们根据打印的地址可以看出不可变字典在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象
test6
对可变字典进行copy&mutableCopy
void test6()
{
NSMutableDictionary *dict1 = [ initWithObjectsAndKeys:@"jack", @"name", nil];
NSDictionary *dict2 = ; // 深拷贝
NSMutableDictionary *dict3 = ; // 深拷贝
NSLog(@"%p %p %p", dict1, dict2, dict3);
}
https://i-blog.csdnimg.cn/direct/fb82e8a116564fa193004e365a022e84.png
结论
https://i-blog.csdnimg.cn/direct/d40dedbcd8b04ceda265f2574e4a943b.png
只要记住copy的目标是为了，修改拷贝后的数据不影响拷贝前的数据，修改拷贝前的数据不影响拷贝后的数据，结论都可以退出来
[*]三个容器的结论都是一样的
[*]只有不可变容器使用不可变拷贝（copy）时，才会浅拷贝。 由于只有这样，修改数据才不会相互影响
[*]除了上述环境，其他环境都是深拷贝
让本身的类用 copy 修饰符
我们copy属性一般只对NSString NSArray NSDictionary NSSet等这些可用，假如我们要对我们的类对象进行copy实现，我们应该怎么做呢?
若想令本身所写的对象具有拷贝功能，则需实现 NSCopying 协议。如果自界说的对象分为可变版本与不可变版本，那么就要同时实现 NSCopying 与 NSMutableCopying 协议。
copy&strong实现原理
两者的区别
[*]copy:用该修饰符进行修饰的属性,在调用该属性的set方法时,会进行一次copy操纵,新开辟一块内存区域,所以原对象指针指向的内存区域值被修改不会造成影响.由于做了一次深拷贝.
[*]strong:用该修饰符进行修饰的属性,引用计数+1,但仅仅拷贝了指针,实际跟原指针指向同一块内存区域,所以原指针指向的内存区域值被修改之后,新的对象值也会被修改.这里仅仅是浅拷贝.
copy内部做了什么处理
现在来看下到底copy到底是做了什么,才能保证值是不可变的.
这里我们通过clang的编译下令将oc文件编译成底层的c++源码一探究竟.通过下令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc xxx.m将对应的.m文件编译成c++文件xxx.cpp,由于编译后会产生许多体系的代码,这里我们只贴上我们本身写的代码:
static void _I_ViewController_testStringCopy(ViewController * self, SEL _cmd) {
NSMutableString *mut = ((NSMutableString * _Nonnull (*)(id, SEL, NSString * _Nonnull))(void *)objc_msgSend)((id)objc_getClass("NSMutableString"), sel_registerName("stringWithString:"), (NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_3);
((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setCopyedStr:"), (NSString *)mut);
((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setStrongStr:"), (NSString *)mut);
((void (*)(id, SEL, NSString * _Nonnull))(void *)objc_msgSend)((id)mut, sel_registerName("appendString:"), (NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_4);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_5, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("copyedStr")));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_6, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("strongStr")));
}
static NSString * _I_ViewController_copyedStr(ViewController * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_copyedStr)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);
static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }
static NSString * _I_ViewController_strongStr(ViewController * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)); }
static void _I_ViewController_setStrongStr_(ViewController * self, SEL _cmd, NSString *strongStr) { (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)) = strongStr; }
这里留意下这两个属性的set方法的实现
static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }
static void _I_ViewController_setStrongStr_(ViewController * self, SEL _cmd, NSString *strongStr) { (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)) = strongStr; }
这里可以看出使用copy修饰的属性跟strong修饰的属性底层的set实现是不同的,strong的实现就是根据地址偏移找到对应的实例变量,然后直接赋值,所以当对象的指针指向的内存区域被修改之后,属性值也会同步被修改。
而使用copy修饰的其set方法内部调用了extern “C” __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);这个函数,第一个参数为属性的实例对象,第二个参数为SEL方法,第三个参数offset,是相对于self的偏移,用来找对应的成员变量的,第四个是新值,第五个是是否为原子性atomic,最后一个为是否需要进行copy操纵。
通过clang编译出来的源码目前只能看到这个水平,我们需要去苹果OC源码地址(将oc的源码下载下来,打开工程去检察对应的函数实现)去检察objc_setProperty这个函数的具体实现才能知道内部做了什么操纵。
通过检察源码,objc_setProperty具体实现如下
void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy)
{
bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
bool mutableCopy = (shouldCopy == MUTABLE_COPY);
reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}
在上面编译出来的c++源码中能看到体系调用这个函数的时候, shouldCopy设置的是1(最后一个参数)
static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }
所以这里告诉体系,这个对象需要进行拷贝。
bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
bool mutableCopy = (shouldCopy == MUTABLE_COPY);
这里是有两个copy标识的,当shouldCopy=1,而且不是mutable copy时需要copy操纵,如果shouldCopy为mutable copy时,进行mutable copy操纵(这里的MUTABLE_COPY就是个宏界说#define MUTABLE_COPY 2)。
接下来看实际内部真正实现的函数reallySetProperty:
static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
if (offset == 0) {
object_setClass(self, newValue);
return;
}
id oldValue;
id *slot = (id*) ((char*)self + offset);
if (copy) {
newValue = ;
} else if (mutableCopy) {
newValue = ;
} else {
if (*slot == newValue) return;
newValue = objc_retain(newValue);
}
if (!atomic) {
oldValue = *slot;
*slot = newValue;
} else {
spinlock_t& slotlock = PropertyLocks;
slotlock.lock();
oldValue = *slot;
*slot = newValue;
slotlock.unlock();
}
objc_release(oldValue);
}
当copy或者mutableCopy为true时会调用copyWithZone/mutableCopyWithZone对属性进行一层深拷贝,这里就可以解释为什么用copy为什么原属性不会被修改,由于内存地址不是同一块了.而copy修饰的属性copy为true,mutableCopy为flase,所以只要是被copy修饰的属性,不管传入的值是否是可变的,最终赋值给属性后都是不可变的,由于这里调用了copyWithZone方法。
总结
所以具体NSString还有集合(NSArray、NSDictionary、NSSet)对象是否需要使用copy来修饰,完全可以根据环境来设置,如果这个值可以100%保证不会被修改的,那么使用strong即可,如果存在被修改的风险的则优先考虑使用copy来修饰。
使用copy修饰符会增加部分性能的斲丧,从源码实现可以看出,copy修饰的对象底层实现的时候都需要进行判断,是否需要copy操纵,如果项目过于巨大,copy修饰符使用过多也会造成性能斲丧,所以如果这个值不存在被修改的风险,建议用strong优化性能。
容器的里面的内容的深浅拷贝
使用copy、mutableCopy对集合对象进行的深浅拷贝是针对集合对象本身的
使用 copy、mutableCopy 对集合对象（NSArray、NSDictionary、NSSet）进行的深浅拷贝是针对集合对象本身的，对集合中的对象执行的默认都是浅拷贝。也就是说只拷贝集合对象本身，而不复制其中的数据。重要缘故原由是，集合内的对象未必都能拷贝，而且调用者也未必想在拷贝集适时一并拷贝其中的每个对象。
如果想要深拷贝集合对象本身的同时，对其元素也进行copy操纵，可使用一下方法：
NSArray* deepCopyArray = [ initWithArray: someArray copyItems: YES];
这样集合中的每一个对象都会收到copyWithZone:消息，需要留意的是集合中的对象都必须符合NSCopying 协议，否则会导致程序崩溃或中断
copyWithZone:是一个用于实现对象复制的方法，当被调用时，方法内部会先创建一个新实例，再将当前对象self的属性值复制到新实例中，最后返回新实例
留意：
initWithArray: copyItems: 方法不是所有环境下都深拷贝集合对象本身的。如果执行[ initWithArray: @[] copyItems: aBoolValue];，也就是原对象为不可变的空数组的话，对原对象本身执行的是浅拷贝，苹果对 @[] 使用了享元
享元是一种计划模式，详情见这篇博客：享元模式
那么如何实现真正的深拷贝（完全拷贝）呢？
先说结论：先归档后解档
从上面的叙述可知，如果集合中的对象的copy操纵是浅拷贝，那么对于集合来说还不是真正意义上的拷贝。比如，现需要对一个NSArray<NSArray *>对象进行真正的深拷贝，那么内层数组及其内容元素也应该执行深拷贝，可以对该集合对象进行归档然后解档，只要集合中的对象都符合 NSCoding 协议。而且，使用这种方式，无论集合中存储的模型对象嵌套多少层，都可以实现深拷贝，但前提是嵌套的子模型也需要符合 NSCoding 协议才行，否则也会导致程序崩溃或中断
以下为真正的深拷贝：
NSArray *trueDeepCopyArray = ];
在这段代码中，oldArray被传递给archivedDataWithRootObject:方法，并返回一个包罗该oldArray对象及其关联数据的NSData对象，通过将前一步得到的NSData对象传递给unarchiveObjectWithData:方法，我们得到了一个解档后的对象，即trueDeepCopyArray
通过这个过程，我们实现了oldArray的深拷贝，得到了一个内容与原始数组相同的新数组trueDeepCopyArray，oldArray及其所有的元素必须符合 NSCoding 协议。如果其中的某个元素不支持归档，则可能会导致错误
https://i-blog.csdnimg.cn/direct/fefb9d53078d42ed9a61595ed3174ef3.png
就原对象和副本对象的可变性而言
使用initWithArray: copyItems: YES时，生成的副本集合中的对象（下一个级别）是不可变的，而更深层级的对象仍旧保持其之前的可变性。换句话说，副本集合的第一级别是不可变的，但更深层级的对象仍旧可以进行修改
来看这段代码
NSArray* oldArray = @[@[].mutableCopy];
NSArray* deepCopyArray = [ initWithArray: oldArray copyItems: YES];
NSMutableArray* mArray = deepCopyArray; // deepCopyArray 已经被深拷贝为 NSArray （不可变）对象
;
起首创建了一个空的NSArray实例[]，并调用mutableCopy方法创建该数组的可变副本，即一个NSMutableArray实例，最后放进oldArray中。用此方法深拷贝后，deepCopyArray已然不可变。因此给mArray添加对象时程序会报错
而归档解档集合的方式可以保存集合对象所有级别的可变性，就像在归档之前一样。通过归档解档，可以以完备的形式将可变集合对象存储到磁盘上，并在需要时重新加载，保存了集合对象层次结构及其可变性
实现对自界说对象的拷贝
实现对自界说对象的拷贝，需要服从NSCopying 协议，并实现copyWithZone:方法。
[*]如果要浅拷贝，copyWithZone: 方法就返回当前对象：return self;
- (id)copyWithZone:(NSZone *)zone {
return self;
}
如果要深拷贝，copyWithZone: 方法中就创建新对象，并给盼望拷贝的属性赋值，然后将其返回。如果有嵌套的子模型也需要深拷贝，那么子模型也需符合NSCopying 协议，且在属性赋值时调用子模型的copy方法，以此类推。
@interface Dog : NSObject <NSCopying>
@property (nonatomic, copy) NSString *name;
@end
@implementation Dog
- (id)copyWithZone:(NSZone *)zone {
Dog *copy = [ init];
copy.name = self.name;
return copy;
}
@end
@interface Person : NSObject <NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, copy) Dog *dog;
@end
@implementation Person
- (id)copyWithZone:(NSZone *)zone {
Person *copy = [ init];
copy.name = self.name;
copy.age = self.age;
copy.dog = ; //调用了嵌套子模型Dog的copy方法进行深拷贝
return copy;
}
@end
如果自界说对象支持可变拷贝和不可变拷贝，那么还需要服从NSMutableCopying 协议，并实现mutableCopyWithZone:方法，返回可变副本。而copyWithZone:方法返回不可变副本。我们可根据需要调用该对象的 copy 或 mutableCopy 方法来进行不可变拷贝或可变拷贝。
@interface Person : NSObject <NSMutableCopying, NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end
@implementation Person
- (id)mutableCopyWithZone:(NSZone *)zone {
Person *copy = [ init];
copy.name = ; //使用可变拷贝的方式来生成可变副本
copy.age = self.age;
return copy;
}
- (id)copyWithZone:(NSZone *)zone {
Person *copy = [ init];
copy.name = self.name; //使用不可变拷贝的方式来生成不可变副本
copy.age = self.age;
return copy;
}
@end
面试题
1. 请简单先容一下iOS的浅拷贝和深拷贝？
答：
[*]浅拷贝：指针的拷贝，实际上拷贝了指向原来对象的指针，不会创建新的对象！
[*]深拷贝：拷贝对象的具体内容，创建新的对象。拷贝结束后，两个对象存的值是相同的，但是内存地址不一样！（至少有一层是深拷贝）
2. 请问NSString属性用什么修饰符修饰，为什么用这个修饰符修饰？
答：
开发中NSString属性用copy修饰符修饰。
之所以用copy来修饰NSString属性，是由于可以制止赋值泉源是NSMutableString的时候，改变可变字符串的值会影响不可变字符串的值。之所以用copy后就不会影响其原有值，是由于用copy修饰不可变字符串，在赋值的时候，在setter方法中会对赋值泉源执行一次copy操纵，当对可变类型执行copy操纵，返回新的不可变对象，纵然改变了泉源数据，也不会影响copy修饰的不可变属性！所以用copy修饰NSString属性，也可以保证数据安全，不受污染！
3. 你了解iOS中的完全拷贝吗？实现方法？
答：
完全拷贝的概念是相对于深拷贝来说的。在深拷贝的明白中有一种说法是至少是一层深拷贝，比如，我们对容器类型的对象执行一次mutableCopy操纵时，就进行了深拷贝，但这次深拷贝是单层深拷贝，也就是说容器内存地址发生了变化，但容器内元素的内存地址没有发生变化，我们称它为单层深拷贝，并不是理论上的完全深拷贝！（容器类型的内容拷贝，仅限于对象本身，对象元素仍旧是指针拷贝）
实现方法：
[*]
[*]使用以下方法： 且集合中的对象都必须符合NSCopying 协议
NSArray* deepCopyArray = [ initWithArray: someArray copyItems: YES];
[*]
[*]先归档后解档
4.如何实现自界说类的深浅拷贝？
体系提供的一些类，比如NSString，NSArray，NSDictionry都遵循了NSCopying和NSMutableCopying协议，所以我们可以直接调用copy/mutableCopy方法。我们自界说的类也想要实现深浅拷贝的功能，我们自界说的类也需要遵循NSCopying和NSMutableCopying协议,并实现对应的协议方法！
自界说的类实现浅拷贝：遵循NSCopying协议，实现copyWithZone方法，方法内返回self！
自界说的类实现深拷贝：遵循NSMutableCopying协议，实现mutableCopyWithZone方法，方法内创建新对象，并把当前类的属性依次赋值给新对象的属性，最后返回这个新的对象！
实现自界说A类的深拷贝的时候，如果A类中嵌套B类，那么B类也要实现NSMutableCopying协议，现mutableCopyWithZone方法，方法内创建新对象，并把当前类的属性依次赋值给新对象的属性，最后返回这个新的B对象！而且，在A类的mutableCopyWithZone方法中， newA.b = 。
这种实现方式只针对简单的单层的类！
上述是根本的实现方式！
下面先容一种使用Runtime+KVC方式给新对象进行赋值！参考代码实现！（这只是浅拷贝，面试别说了）
CustomModel *m1 = ;
m1.name = @"Shaw";
m1.age = 27;
CustomModel *m2 = ;
m2.name = @"CTT";
m2.age = 28;
NSLog(@"%@&%@", m1.name, m2.name);
// 打印结果：Shaw&CTT
@interface CustomModel : NSObject <NSCopying>
@property (nonatomic, strong) NSString *name;
@property (nonatomic, assign) int age;
@end
@implementation CustomModel
- (id)copyWithZone:(NSZone *)zone {
CustomModel *copy = [[ alloc] init];
unsigned int propertyCount = 0;
objc_property_t *propertyList = class_copyPropertyList(, &propertyCount);
for (int i = 0; i < propertyCount; i++ ) {
objc_property_t thisProperty = propertyList;
const char* propertyCName = property_getName(thisProperty);
NSString *propertyName = ;
id value = ;
;
}
return copy;
}
// 注意此处需要实现这个函数，因为在通过Runtime获取属性列表时，会获取到一个名字为hash的属性名，这个是系统帮你生成的一个属性
- (void)setValue:(id)value forUndefinedKey:(NSString *)key {}
代码实现解释：
[*]KVC：通过 valueForKey: 和 setValue:forKey: 轻松地获取和设置对象的属性值，而无需显式调用 getter 或 setter 方法。
[*]Runtime：通过 class_copyPropertyList 动态获取对象的属性列表，使得 copyWithZone: 方法可以自动顺应类中的所有属性，纵然属性列表发生变化也不需要手动修改代码。
[*]setValue:forUndefinedKey: 的空实现保证了 KVC 操纵的安全性，制止未界说键导致的崩溃。
5.如果自界说的类有多层嵌套，有没有方法实现自界说类的深拷贝？
答：
解档和归档
[*]1 . 自界说类包括嵌套的类都要实现NSCoding协议，并实现encodeWithCoder/initWithCoder协议方法，
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]