iOS：copy的本质

时间 2019-12-31

标签 ios copy 本质栏目 iOS 繁體版

原文原文链接

基本概念

就 iOS 开发而言，关于 copy 的几个概念：数组

拷贝：即复制，目的是产生副本，让原对象和副本相互独立，互不影响；
不可变拷贝：即 copy 方法，不管原对象是否可变，都产生不可变副本；
可变拷贝：即 mutableCopy 方法，不管原对象是否可变，都产生可变副本；
深拷贝：内容拷贝，产生新的对象；
浅拷贝：指针拷贝，不产生新的对象；

由上可知，copy 和深拷贝是两个概念，二者并不必定相等，先给结果：bash

源对象不可变时，copy 方法就是浅拷贝；
源对象可变时，copy 方法就是深拷贝；
mutableCopy 方法不管何种状况都是深拷贝；

代码分析

关闭 ARC 的状况下，先看两段代码：app

状况一：NSString

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *str1 = [[NSString alloc] initWithFormat:@"123abcdefghijklmn"];
        NSString *str2 = [str1 copy];
        NSMutableString *str3 = [str1 mutableCopy];
        
        NSLog(@"%zd %zd %zd",str1.retainCount, str2.retainCount, str3.retainCount);
        NSLog(@"%p %p %p",str1, str2, str3);
    }
    return 0;
}
复制代码

猜一猜打印的结果是什么？结果以下：iphone

2019-12-26 17:23:23.020793+0800 XKCopyTest[1862:60872367] 2 2 1
2019-12-26 17:23:23.021176+0800 XKCopyTest[1862:60872367] 0x100610460 0x100610460 0x1006103b0
Program ended with exit code: 0
复制代码

先不看引用计数器，先看看内存地址，从打印结果中能够看出：函数

str1 是 NSString类型，属于不可变对象；
str2 中的调用的 copy方法表示是不可变拷贝，须要获得一个不可变副本；
str2 的地址和 str1 地址相等，没有产生新的对象；

由此能够进一步得出第一个结论：ui

str2 中的拷贝是浅拷贝；

由于str2地址不变，指向的仍然是str1所指向的那个对象，没有产生新的对象，因此此时的拷贝是浅拷贝；atom

浅拷贝中的 copy 方法等价于retain

由于是浅拷贝，没有产生新的对象，指针 str2 仍然指向源对象，因此此时copy方法执行的逻辑等价于retain，也就是仅仅让源对象的引用计数器增长了1，因此最终 str1.retainCount的结果是 2 。由于 str2 指向源对象，因此天然而言的str2.retainCount的打印结果也是2。spa

这里须要解释下如此设计的缘由，就像咱们在使用 PC 文件时进行拷贝同样，拷贝的本质是要生成一个和源文件相互独立，互不干扰的副本，说具体点就是两个文件修改以后不影响另一个文件。由于 str1 是不可变对象，copy方法生成的也是不可变对象，源对象原本就不可变，因此就不存在源对象被修改的状况了，因此直接把str2指向源对象，既能够实现拷贝的相互独立，互不干扰的宗旨，还不用生成新的内存，节省内存空间，一箭双雕。设计

再来看看 str3，从打印结果中咱们能够得出：指针

str3 中调用的mutableCopy表示可变拷贝，须要获得一个可变的副本；
str3的地址和str1不相等，证实产生了一个新的对象；

由于产生了新的对象，因此str3中的拷贝操做属于深拷贝。str3也就指向了新产生的对象的内存地址，因而乎引用计数器就是 1。而 str1和str2指针所指向的对象是相同的，且被str1和str2指向(引用)，因此最终引用计数器打印结果为2。

状况二：NSMutableString

将str1改为可变类型，也就是NSMutableString，代码以下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableString *str1 = [[NSMutableString alloc] initWithFormat:@"123abcdefghijklmn"];
        NSString *str2 = [str1 copy];
        NSMutableString *str3 = [str1 mutableCopy];
        
        NSLog(@"%zd %zd %zd",str1.retainCount, str2.retainCount, str3.retainCount);
        NSLog(@"%p %p %p",str1, str2, str3);
    }
    return 0;
}
复制代码

打印结果又是怎么样的？结果以下：

2019-12-26 17:29:07.661591+0800 XKCopyTest[1937:60876834] 1 1 1
2019-12-26 17:29:07.661965+0800 XKCopyTest[1937:60876834] 0x10057c600 0x1005086d0 0x100508700
Program ended with exit code: 0
复制代码

理解了状况一，再来看这个就比较简单了，从打印结果和代码中能够得出结论：

str2 中的拷贝属于深拷贝；

str2 中的 copy 仍然属于不可变拷贝，可是源对象是可变对象，因此一定会生成一个新对象，产生了新的对象就属于内容拷贝，天然就是深拷贝；

mutableCopy 一定是深拷贝；

mutableCopy 须要生成可变的副本，因此不管源对象是可变对象仍是不可变对象，mutableCopy方法都会生成一个新的对象，因此一定是深拷贝。

对于 array、dictionary、data，也是同理，本文就再也不赘述。

copy 修饰属性

上文中知道了，拷贝分深拷贝和浅拷贝，那么@property中的copy关键字是干吗的呢？有没有 mutablecopy 关键字呢？

先说结论：

属性中 copy 关键字的做用就是调用被赋值给属性的对象的copyWithZone方法，并将返回值赋值给属性;

再来看源码, 首先看一段咱们经常使用的属性声明代码：

@interface XKPerson()
@property (copy, nonatomic) NSString *name;
@property (assign, nonatomic) NSInteger age;

@end

@implementation XKPerson

@end
复制代码

使用编译指令生成 cpp 文件：

xcrun  -sdk  iphoneos  clang  -arch  arm64  -rewrite-objc XKPerson.m -o XKPerson.cpp
复制代码

而后咱们来找找property最后生成的代码是怎样的，cpp 文件中关于属性的实现代码如图所示：

// @interface XKPerson()
// @property (copy, nonatomic) NSString *name;
// @property (assign, nonatomic) NSInteger age;
/* @end */

// @implementation XKPerson

static NSString * _I_XKPerson_name(XKPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_XKPerson$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_XKPerson_setName_(XKPerson * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct XKPerson, _name), (id)name, 0, 1); }

static NSInteger _I_XKPerson_age(XKPerson * self, SEL _cmd) { return (*(NSInteger *)((char *)self + OBJC_IVAR_$_XKPerson$_age)); }
static void _I_XKPerson_setAge_(XKPerson * self, SEL _cmd, NSInteger age) { (*(NSInteger *)((char *)self + OBJC_IVAR_$_XKPerson$_age)) = age; }
// @end
复制代码

也就是说，@property只是告诉编译器，帮我生成 setter和 getter方法，也就是声明并实现了四个方法：

static NSString * _I_XKPerson_name
static void I_XKPerson_setName
static NSInteger _I_XKPerson_age
static void I_XKPerson_setAge

这里，由于咱们在探究属性中的 copy，并且 copy 只在设置属性的时候起做用，因此咱们只须要关注 _I_XKPerson_setName_ 这个方法便可，其核心是调用了objc_setProperty()这个函数，那么咱们来到 objc4 的源码，下载源码后看看objc_setProperty这个函数作了啥，代码以下：

#define MUTABLE_COPY 2

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);
    // copy 和 mutableCopy最多只有一个为真(1)
    reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}
复制代码

其他代码就不贴了，MUTABLE_COPY值为2，而setter中传的值为1，最终会进入到reallySetProperty这个方法：

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) {
        // 修改 isa 指向
        object_setClass(self, newValue);
        return;
    }

    id oldValue;
    id *slot = (id*) ((char*)self + offset);

    // copy的逻辑
    if (copy) {
        // 属性修饰关键字只有 copy
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        // 属性修饰关键字只有 copy , 这里是实现了 mutableCopying 协议时的处理逻辑
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        newValue = objc_retain(newValue);
    }

    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }

    // 释放原对象
    objc_release(oldValue);
}
复制代码

其实这段代码仍是挺经典的，可是咱们只看 copy 的部分：

// copy的逻辑
    if (copy) {
        // 属性修饰关键字只有 copy ，因此最终会进入到这里
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        // 属性修饰关键字只有 copy , 这里是实现了 mutableCopying 协议时的处理逻辑
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        
        // NSString等不可变对象调用copy，其内部的代码逻辑会走到这里来
        // 此时 copy 不产生新的对象，属于浅拷贝，因此 copy 和 retain 的代码逻辑等价(可是可不能将 copy 关键字替换成 retain 哦😯~)
        newValue = objc_retain(newValue);
    }
复制代码

从源码中就一目了然了：

若是是 copy 方法，则调用对象的 copyWithZone方法；
若是是mutablecopy，则调用对象的mutableCopyWithZone 方法；
若是 copy = 0，mutablecopy = 0，那么最终会调用objc_retain方法；

其中，使用retain修饰属性时，就是第三种状况，代码中也能够获得验证，修改copy为 retain后编译的结果：

// 最后一个参数由 1 变成了 0
static void _I_XKPerson_setName_(XKPerson * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct XKPerson, _name), (id)name, 0, 0); }
复制代码

另外，若是使用 strong 和 assign修饰，最终 setter 不调用 objc_setProperty方法而是经过偏移量进行指针赋值或者直接赋值，具体就再也不这里探讨了~~

这里留个疑问：

若是用 copy 修饰，那么属性最终转化成的 setter 中执行的 objc_setProperty 方法的传值中，最后一个参数永远为1。而objc_setProperty内部调用的也是reallySetProperty方法。为1时，调用reallySetProperty方法中的参数永远是bool copy = 1, bool mutablecopy = 0，也就是会走到copyWithZone这层逻辑。而使用 retain修饰属性，参数bool copy = 0, bool mutablecopy = 0，会走到obje_retain这层逻辑，概括以下：

关键字	参数copy的值	参数mutablecopy的值	代码逻辑
retain	0	0	obje_retain()
copy	1	0	copyWithZone()

只有objc_setProperty最后一个参数为 2 时，才会走到 mutableCopy 的逻辑，因此reallySetProperty方法中的mutablecopyWithZone的代码什么时候会被调用呢？？？

使用 copy 修饰字符串意义

先说结论，使用 copy 修饰属性的意义在于：

明确告诉使用者，设计者不但愿且不能你直接修改属性对象所指向的内存地址的值；

不但愿体如今使用使用 NSString 类型来声明属性，这样若是使用 appendString:的方法，就报报编译错误。

可是，若是使用 strong 来修饰字符串属性，加上强制类型转换，仍然能够实现直接修改内存地址中的值：

// person对象中使用 strong 修饰 属性
@property (strong, nonatomic) NSString *name1;
XKPerson *p = [XKPerson new];
NSMutableString *name = [[NSMutableString alloc] initWithFormat:@"%@",@"Jack"];
// 此时若是是用 strong 修饰 name，虽然声明的是 NSString 对象，但实际类型是 NSMutableString 类型
p.name = name;
[(NSMutableString *)p.name appendFormat:@"1"];
复制代码

以上代码就实现了直接修改属性所指向的内存地址中的值，此时修改为使用 copy 修饰，由于调用的copyWithZone，结果返回的一定是不可变类型，因此即便赋值时是NSMutableString类型，最终获得的仍然是NSString类型，这样就起到了预期的效果；

因此，NSString 类型使用 copy 修饰是最好不过的~~~

这里还涉及到一个场景，好比咱们开发中，但愿字符串属性跟随某个字符串对象的值同时改变，这个时候就要使用 strong + NSMutableString了：

@property (strong, nonatomic) NSMutableString *name;

// 使用
XKPerson *p = [XKPerson new];
    NSMutableString *name = [NSMutableString stringWithFormat:@"王"];
    p.name = name;
    NSLog(@"%@",p.name);
    [name appendString:@"小二"];
    NSLog(@"%@",p.name);
复制代码

结果：

2019-12-27 17:53:51.730 XKStringTest[10172:63201310] 王
2019-12-27 17:53:51.731 XKStringTest[10172:63201310] 王小二
复制代码

这个时候使用 copy 修饰反而会崩溃，和使用 copy 修饰 NSMutableArray时，往数组中新增元素时崩溃是一个道理哦😯~~~

copy 协议

上一章节讲到了属性修饰中 copy 关键字的本质是调用copyWithZone方法。之因此可以使用 copy 修饰字符串、数组等，是由于这些系统对象实现了 copy 相关的协议。

因此，这里就涉及到一个问题：自定义copyWithZone方法。日常咱们使用 copy 修饰的最多的就是字符串

所以，OC 中给咱们提供了两个协议：

@protocol NSCopying
- (id)copyWithZone:(nullable NSZone *)zone;
@end

@protocol NSMutableCopying
- (id)mutableCopyWithZone:(nullable NSZone *)zone;
@end
复制代码

具体实现以下：

- (id)copyWithZone:(NSZone *)zone {
    XKPerson *newP = [[XKPerson allocWithZone:zone] init];
    newP.name = self.name;
    newP.age = self.age;
    return newP;
}

- (id)mutableCopyWithZone:(NSZone *)zone {
    XKPerson *newP = [[XKPerson allocWithZone:zone] init];
    newP.name = self.name;
    newP.age = 10;
    return newP;
}
复制代码

使用：

XKPerson *p = [XKPerson new];
    p.name = @"Jack";
    p.age = 18;
    XKPerson *p1 = [p copy];
    XKPerson *p2 = [p mutableCopy];
    NSLog(@"%p %p %p", p, p1, p2);
    
    p1.name = @"Lucy";
    NSLog(@"%@",p1.name);
复制代码

结果：

2019-12-27 17:42:11.326 XKStringTest[9991:63192515] 0x7ae30b10 0x7ae31340 0x7ae313e0
2019-12-27 17:42:11.327 XKStringTest[9991:63192515] Lucy
复制代码

copy 在数据模型 model 中时可能会较多使用 copy，此时实现copy协议便可，但在平时自定义对象使用 copy 并很少，这两个协议就很少说了~~

Block 为何使用 copy 修饰

略，会在 block进阶中讲到~~

总结

以上，总结下 copy 的几个重点，方便记忆：

copy 的目的是建立一个互不干扰，相互独立的副本；
copy 不管是直接调用仍是修饰属性，其本质是调用copyWithZone和mutableCopyWithZone方法；
深浅复制的区别在于返回值是否为新建立的对象，和调用 copy 的哪一个方法无关；
使用 copy 修饰属性的关键目的是告诉使用者，这个不要直接修改属性所指向内存中的值；
修饰可变类型的对象，好比可变数组，严禁使用 copy 修饰；