【iOS】copy&strong原理+深浅拷贝+完全拷贝

瑞星  金牌会员 | 2024-8-8 20:59:05 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 641|帖子 641|积分 1923

Copy&Strong原理

Copy探究

在答复copy的各种问题前，我们需要先了解我们为什么要使用copy。



    • 拷贝的目标 ： 产生一个副本对象，跟源对象互不影响
       

    • 修改了源对象，不会影响副本对象
    • 修改了副本对象，不会影响源对象


    • iOS提供了2个拷贝方法
       


      • copy，不可变拷贝，产生不可变副本


      • mutableCopy， 可变拷贝，产生可变副本



    • 深拷贝和浅拷贝
       


      • 深拷贝 ： 内容拷贝，产生新的对象


      • 浅拷贝 ： 指针拷贝， 没有产生新的对象


下面是是6个test，分别是 可变/不可变 的 字符串/数组/字典 对应的 copy和mutableCopy操纵。
复习的时候都不用看，直接看结论，想清晰都很简单
test1

对不可变字符串进行copy&mutableCopy操纵
  2. void test1()
  3. {
  4.         NSString *str1 = [NSString stringWithFormat:@"test"];
  5.         NSString *str2 = [str1 copy]; // 返回的是NSString
  6.         NSMutableString *str3 = [str1 mutableCopy]; // 返回的是NSMutableString
  7.         NSLog(@"%p %p %p", str1, str2, str3);
  8. }
复制代码

我们根据打印的地址可以看出不可变字符串在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象
test2

对可变字符串进行copy&mutableCopy操纵
  2. void test2()
  3. {
  4.         NSMutableString *str1 = [[NSMutableString alloc] initWithFormat:@"test"]; // 1
  5.         NSString *str2 = [str1 copy]; // 深拷贝
  6.         NSMutableString *str3 = [str1 mutableCopy]; // 深拷贝
  7.         NSLog(@"%p %p %p", str1, str2, str3);
  8. }
复制代码

我们根据打印的地址可以看出对于可变字符串不论是copy还是mutableCopy都是深拷贝
test3

对不可变数组进行copy&mutableCopy操纵
  2. void test3()
  3. {
  4.         NSArray *array1 = [[NSArray alloc] initWithObjects:@"a", @"b", nil];
  5.         NSArray *array2 = [array1 copy]; // 浅拷贝
  6.         NSMutableArray *array3 = [array1 mutableCopy]; // 深拷贝
  8.         NSLog(@"%p %p %p", array1, array2, array3);
  9. }
复制代码

我们根据打印的地址可以看出不可变数组在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象
test4

对可变数组进行copy&mutableCopy操纵
  2. void test4()
  3. {
  4.         NSMutableArray *array1 = [[NSMutableArray alloc] initWithObjects:@"a", @"b", nil];
  5.         NSArray *array2 = [array1 copy]; // 深拷贝
  6.         NSMutableArray *array3 = [array1 mutableCopy]; // 深拷贝
  8.         NSLog(@"%p %p %p", array1, array2, array3);
  9. }
复制代码

我们根据打印的地址可以看出对于可变数组不论是copy还是mutableCopy都是深拷贝
test5

对不可变字典进行copy&mutableCopy操纵
  2. void test5()
  3. {
  4.         NSDictionary *dict1 = [[NSDictionary alloc] initWithObjectsAndKeys:@"jack", @"name", nil];
  5.         NSDictionary *dict2 = [dict1 copy]; // 浅拷贝
  6.         NSMutableDictionary *dict3 = [dict1 mutableCopy]; // 深拷贝
  8.         NSLog(@"%p %p %p", dict1, dict2, dict3);
  9. }
复制代码

我们根据打印的地址可以看出不可变字典在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象
test6

对可变字典进行copy&mutableCopy
  2. void test6()
  3. {
  4.         NSMutableDictionary *dict1 = [[NSMutableDictionary alloc] initWithObjectsAndKeys:@"jack", @"name", nil];
  5.         NSDictionary *dict2 = [dict1 copy]; // 深拷贝
  6.         NSMutableDictionary *dict3 = [dict1 mutableCopy]; // 深拷贝
  8.         NSLog(@"%p %p %p", dict1, dict2, dict3);
  10. }
复制代码

结论


只要记住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,由于编译后会产生许多体系的代码,这里我们只贴上我们本身写的代码:
  1.   static void _I_ViewController_testStringCopy(ViewController * self, SEL _cmd) {
  3.     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);
  4.    
  5.     ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setCopyedStr:"), (NSString *)mut);
  6.     ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setStrongStr:"), (NSString *)mut);
  7.    
  8.     ((void (*)(id, SEL, NSString * _Nonnull))(void *)objc_msgSend)((id)mut, sel_registerName("appendString:"), (NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_4);
  9.    
  10.     NSLog((NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_5, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("copyedStr")));
  11.     NSLog((NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_6, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("strongStr")));
  13. }
  15. static NSString * _I_ViewController_copyedStr(ViewController * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_copyedStr)); }
  16. extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);
  18. static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }
  21. static NSString * _I_ViewController_strongStr(ViewController * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)); }
  22. static void _I_ViewController_setStrongStr_(ViewController * self, SEL _cmd, NSString *strongStr) { (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)) = strongStr; }
复制代码
这里留意下这两个属性的set方法的实现
  1. static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }
  4. 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具体实现如下
  1.    void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy)
  2. {
  3.     bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
  4.     bool mutableCopy = (shouldCopy == MUTABLE_COPY);
  5.     reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
  6. }
复制代码
在上面编译出来的c++源码中能看到体系调用这个函数的时候, shouldCopy设置的是1(最后一个参数)
  1. static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }
复制代码
所以这里告诉体系,这个对象需要进行拷贝。
  1. bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
  2. bool mutableCopy = (shouldCopy == MUTABLE_COPY);
复制代码
这里是有两个copy标识的,当shouldCopy=1,而且不是mutable copy时需要copy操纵,如果shouldCopy为mutable copy时,进行mutable copy操纵(这里的MUTABLE_COPY就是个宏界说#define MUTABLE_COPY 2)。
接下来看实际内部真正实现的函数reallySetProperty:
  1. static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
  2. {
  3.     if (offset == 0) {
  4.         object_setClass(self, newValue);
  5.         return;
  6.     }
  8.     id oldValue;
  9.     id *slot = (id*) ((char*)self + offset);
  11.     if (copy) {
  12.         newValue = [newValue copyWithZone:nil];
  13.     } else if (mutableCopy) {
  14.         newValue = [newValue mutableCopyWithZone:nil];
  15.     } else {
  16.         if (*slot == newValue) return;
  17.         newValue = objc_retain(newValue);
  18.     }
  20.     if (!atomic) {
  21.         oldValue = *slot;
  22.         *slot = newValue;
  23.     } else {
  24.         spinlock_t& slotlock = PropertyLocks[slot];
  25.         slotlock.lock();
  26.         oldValue = *slot;
  27.         *slot = newValue;        
  28.         slotlock.unlock();
  29.     }
  31.     objc_release(oldValue);
  32. }
复制代码
当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操纵，可使用一下方法：
  1. NSArray* deepCopyArray = [[NSArray alloc] initWithArray: someArray copyItems: YES];
复制代码
这样集合中的每一个对象都会收到copyWithZone:消息，需要留意的是集合中的对象都必须符合NSCopying 协议，否则会导致程序崩溃或中断
copyWithZone:是一个用于实现对象复制的方法，当被调用时，方法内部会先创建一个新实例，再将当前对象self的属性值复制到新实例中，最后返回新实例
留意：
initWithArray: copyItems: 方法不是所有环境下都深拷贝集合对象本身的。如果执行[[NSArray alloc] initWithArray: @[] copyItems: aBoolValue];，也就是原对象为不可变的空数组的话，对原对象本身执行的是浅拷贝，苹果对 @[] 使用了享元
享元是一种计划模式，详情见这篇博客：享元模式
那么如何实现真正的深拷贝（完全拷贝）呢？

先说结论：先归档后解档
从上面的叙述可知，如果集合中的对象的copy操纵是浅拷贝，那么对于集合来说还不是真正意义上的拷贝。比如，现需要对一个NSArray<NSArray *>对象进行真正的深拷贝，那么内层数组及其内容元素也应该执行深拷贝，可以对该集合对象进行归档然后解档，只要集合中的对象都符合 NSCoding 协议。而且，使用这种方式，无论集合中存储的模型对象嵌套多少层，都可以实现深拷贝，但前提是嵌套的子模型也需要符合 NSCoding 协议才行，否则也会导致程序崩溃或中断
以下为真正的深拷贝：
  1. NSArray *trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData: [NSKeyedArchiver archivedDataWithRootObject: oldArray]];
复制代码
在这段代码中，oldArray被传递给archivedDataWithRootObject:方法，并返回一个包罗该oldArray对象及其关联数据的NSData对象，通过将前一步得到的NSData对象传递给unarchiveObjectWithData:方法，我们得到了一个解档后的对象，即trueDeepCopyArray
通过这个过程，我们实现了oldArray的深拷贝，得到了一个内容与原始数组相同的新数组trueDeepCopyArray，oldArray及其所有的元素必须符合 NSCoding 协议。如果其中的某个元素不支持归档，则可能会导致错误

就原对象和副本对象的可变性而言
   使用initWithArray: copyItems: YES时，生成的副本集合中的对象（下一个级别）是不可变的，而更深层级的对象仍旧保持其之前的可变性。换句话说，副本集合的第一级别是不可变的，但更深层级的对象仍旧可以进行修改
  来看这段代码
  1. NSArray* oldArray = @[@[].mutableCopy];
  2. NSArray* deepCopyArray = [[NSArray alloc] initWithArray: oldArray copyItems: YES];
  3. NSMutableArray* mArray = deepCopyArray[0]; // deepCopyArray[0] 已经被深拷贝为 NSArray （不可变）对象
  4. [mArray addObject:@""];
复制代码
起首创建了一个空的NSArray实例[]，并调用mutableCopy方法创建该数组的可变副本，即一个NSMutableArray实例，最后放进oldArray中。用此方法深拷贝后，deepCopyArray[0]已然不可变。因此给mArray添加对象时程序会报错
而归档解档集合的方式可以保存集合对象所有级别的可变性，就像在归档之前一样。通过归档解档，可以以完备的形式将可变集合对象存储到磁盘上，并在需要时重新加载，保存了集合对象层次结构及其可变性
实现对自界说对象的拷贝

实现对自界说对象的拷贝，需要服从NSCopying 协议，并实现copyWithZone:方法。


  • 如果要浅拷贝，copyWithZone: 方法就返回当前对象：return self;
  1. - (id)copyWithZone:(NSZone *)zone {
  2.     return self;
  3. }
复制代码
如果要深拷贝，copyWithZone: 方法中就创建新对象，并给盼望拷贝的属性赋值，然后将其返回。如果有嵌套的子模型也需要深拷贝，那么子模型也需符合NSCopying 协议，且在属性赋值时调用子模型的copy方法，以此类推。
  2. @interface Dog : NSObject <NSCopying>
  3. @property (nonatomic, copy) NSString *name;
  4. @end
  6. @implementation Dog
  7. - (id)copyWithZone:(NSZone *)zone {
  8.     Dog *copy = [[Dog alloc] init];
  9.     copy.name = self.name;
  10.     return copy;
  11. }
  12. @end
  14. @interface Person : NSObject <NSCopying>
  15. @property (nonatomic, copy) NSString *name;
  16. @property (nonatomic, assign) NSInteger age;
  17. @property (nonatomic, copy) Dog *dog;
  18. @end
  20. @implementation Person
  21. - (id)copyWithZone:(NSZone *)zone {
  22.     Person *copy = [[Person alloc] init];
  23.     copy.name = self.name;
  24.     copy.age = self.age;
  25.     copy.dog = [self.dog copy]; //调用了嵌套子模型Dog的copy方法进行深拷贝
  26.     return copy;
  27. }
  28. @end
复制代码
如果自界说对象支持可变拷贝和不可变拷贝，那么还需要服从NSMutableCopying 协议，并实现mutableCopyWithZone:方法，返回可变副本。而copyWithZone:方法返回不可变副本。我们可根据需要调用该对象的 copy 或 mutableCopy 方法来进行不可变拷贝或可变拷贝。
  2. @interface Person : NSObject <NSMutableCopying, NSCopying>
  3. @property (nonatomic, copy) NSString *name;
  4. @property (nonatomic, assign) NSInteger age;
  5. @end
  7. @implementation Person
  8. - (id)mutableCopyWithZone:(NSZone *)zone {
  9.     Person *copy = [[Person alloc] init];
  10.     copy.name = [self.name mutableCopy]; //使用可变拷贝的方式来生成可变副本
  11.     copy.age = self.age;
  12.     return copy;
  13. }
  15. - (id)copyWithZone:(NSZone *)zone {
  16.     Person *copy = [[Person alloc] init];
  17.     copy.name = self.name; //使用不可变拷贝的方式来生成不可变副本
  18.     copy.age = self.age;
  19.     return copy;
  20. }
  21. @end
复制代码
面试题

1. 请简单先容一下iOS的浅拷贝和深拷贝？

答：


  • 浅拷贝：指针的拷贝，实际上拷贝了指向原来对象的指针，不会创建新的对象！
  • 深拷贝：拷贝对象的具体内容，创建新的对象。拷贝结束后，两个对象存的值是相同的，但是内存地址不一样！（至少有一层是深拷贝）
2. 请问NSString属性用什么修饰符修饰，为什么用这个修饰符修饰？

答：
开发中NSString属性用copy修饰符修饰。
之所以用copy来修饰NSString属性，是由于可以制止赋值泉源是NSMutableString的时候，改变可变字符串的值会影响不可变字符串的值。之所以用copy后就不会影响其原有值，是由于用copy修饰不可变字符串，在赋值的时候，在setter方法中会对赋值泉源执行一次copy操纵，当对可变类型执行copy操纵，返回新的不可变对象，纵然改变了泉源数据，也不会影响copy修饰的不可变属性！所以用copy修饰NSString属性，也可以保证数据安全，不受污染！
3. 你了解iOS中的完全拷贝吗？实现方法？

答：
完全拷贝的概念是相对于深拷贝来说的。在深拷贝的明白中有一种说法是至少是一层深拷贝，比如，我们对容器类型的对象执行一次mutableCopy操纵时，就进行了深拷贝，但这次深拷贝是单层深拷贝，也就是说容器内存地址发生了变化，但容器内元素的内存地址没有发生变化，我们称它为单层深拷贝，并不是理论上的完全深拷贝！（容器类型的内容拷贝，仅限于对象本身，对象元素仍旧是指针拷贝）
实现方法：



    • 使用以下方法： 且集合中的对象都必须符合NSCopying 协议
      NSArray* deepCopyArray = [[NSArray alloc] 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 = [self.b mutableCopy] 。
这种实现方式只针对简单的单层的类！
上述是根本的实现方式！
下面先容一种使用Runtime+KVC方式给新对象进行赋值！参考代码实现！（这只是浅拷贝，面试别说了）
  2. CustomModel *m1 = [CustomModel new];
  3. m1.name = @"Shaw";
  4. m1.age = 27;
  5. CustomModel *m2 = [m1 copy];
  6. m2.name = @"CTT";
  7. m2.age = 28;
  8.    
  9. NSLog(@"%@&%@", m1.name, m2.name);
  10. // 打印结果：Shaw&CTT
  12. @interface CustomModel : NSObject <NSCopying>
  13. @property (nonatomic, strong) NSString *name;
  14. @property (nonatomic, assign) int age;
  15. @end
  17. @implementation CustomModel
  19. - (id)copyWithZone:(NSZone *)zone {
  20.     CustomModel *copy = [[[self class] alloc] init];
  21.     unsigned int propertyCount = 0;
  22.     objc_property_t *propertyList = class_copyPropertyList([self class], &propertyCount);
  23.     for (int i = 0; i < propertyCount; i++ ) {
  24.         objc_property_t thisProperty = propertyList[i];
  25.         const char* propertyCName = property_getName(thisProperty);
  26.         NSString *propertyName = [NSString stringWithCString:propertyCName encoding:NSUTF8StringEncoding];
  27.         id value = [self valueForKey:propertyName];
  28.         [copy setValue:value forKey:propertyName];
  29.     }
  30.     return copy;
  31. }
  32. // 注意此处需要实现这个函数，因为在通过Runtime获取属性列表时，会获取到一个名字为hash的属性名，这个是系统帮你生成的一个属性
  33. - (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企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

瑞星

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表