谈谈Objective-C的对象拷贝

通常我们在使用@property声明属性的时候,对于NSStringNSArrayNSDictionary经常会使用copy,以及block的时候也会使用copy,接下来就是和所说copy和mutableCopy。先来思考几个问题:

  1. copy与mutableCopy有什么区别?
  2. 使用copy/mutableCopy和直接赋值有什么区别?
  3. 深浅拷贝的区别?
  4. 自定义对象如何实现NSCopying协议?
  5. block为什么需要使用copy?

copy和mutableCopy

在需要复制对象的时候,会用到NSObject类提供的copy和mutableCopy方法,通过这两个方法即可复制已有对象的副本。最常用的是赋值NSString、NSArray、NSDictionary这一类对象,那么copy和mutableCopy究竟是什么?它们有何区别?

copy

copy拷贝出来的对象类型总是不可变类型(例如, NSString, NSArray, NSDictionary等等)

mutableCopy

mutableCopy拷贝出来的对象类型总是可变类型(例如, NSMutableString, NSMutableArray, NSMutableDictionary等等)

代码举例:

1
2
3
NSString * str = @"hello world";
[str copy]; // 拷贝出内容为hello world的NSString类型的字符串
[str mutableCopy]; // 拷贝出内容为hello world的NSMutableString类型的字符串

打印出类名:

同样的,对于不可变的NSArray和可变的NSMutableArray来说,这样的关系总是成立的:

1
2
[NSMutableArray copy] => NSArray
[NSArray mutableCopy] => NSMutableArray

使用copy/mutableCopy和直接赋值有什么区别?

先看一个例子

1
2
3
4
5
6
7
8
9
10
NSMutableArray * arr1 = [NSMutableArray array];
[arr1 addObject:@"A"];

NSArray * arr2 = [NSArray array];
arr2 = arr1;

[arr1 addObject:@"C"];

NSLog(@"arr1 = %@", arr1);
NSLog(@"arr2 = %@", arr2);

这段代码输入如下:

arr1是可变数组,arr2是一个不可变数组,明明可变数组添加对象在赋值之后,arr2也被影响到了。

如果将arr2 = arr1修改为如下:

1
arr2 = [arr1 copy];

然后输出就正常了

这是为什么呢?

原因其实是和OC的多态特性有关,表面上arr2是一个NSArray类型的对象,实际上是指向一个NSMutableArray类型的对象,也就是arr1
我们通过打印arr1arr2两个对象来看就知道了:

  • 在直接赋值的方式下打印:

  • 在使用copy的方式下打印:

一目了然,直接赋值之后,arr1arr2完全就是同一个对象,指向同一个地址,所以赋值之后再给arr1添加对象,打印出的结果肯定也是一样的。而如果使用copy之后赋值,就是两个完全不一样的对象,后续的操作也不会有影响。


深拷贝(deep copy)与浅拷贝(shallow copy)的区别?

首先得清楚什么是深拷贝和浅拷贝?

深拷贝

拷贝出来的对象与原对象地址不一致修改拷贝对象的值对源对象的值没有任何影响。 深拷贝是直接拷贝整个对象内容到另一块内存中。

浅拷贝

拷贝出来的对象与原对象地址一致修改拷贝对象的值会直接影响源对象的值。

可以用一句话总结:浅复制就是指针拷贝;深复制就是内容拷贝

或许会听过这样的说法:copy都是浅拷贝, mutableCopy都是深拷贝
这种浅显的理解是错误的,可以看到之前使用copy的方式下打印出来的对象的地址是不一样的,是深拷贝,这说明用从一个可变对象copy出一个不可变对象时, 是深拷贝而不是浅拷贝

在Foundation框架中,所有的collectioon类在默认的情况下都执行浅拷贝,也就是说只拷贝容器对象本身,不复制其中的数据。这样做的目的是,容器内的对象未必都能拷贝,而且调用者也未必想在拷贝容器时一并拷贝其中的某个对象。

不过通常情况下,执行的都是浅拷贝,如果你所写的对象需要深拷贝,那么可以考虑增加一个专门执行深拷贝的方法。


自定义对象如何实现NSCopying协议

虽然copy方法是在NSObject中的,如果我们自定义一个类(比如Person),向该类的对象发送copy消息,会得到如下结果:

1
2
Person *p = [[Person alloc] init];
Person *p2 = [p copy];

查看苹果官方文档会发现,如果自定义的类要实现copy功能,需要实现copyWithZone方法,(如果想要区分copy和mutableCopy,那么copyWithZone:应该返回不可变副本,而mutableCopyWithZone:应该返回可变副本)。这个时候可以在Person类中添加如下代码:

1
2
3
4
5
6
7
8
@implementation Person

- (instancetype)copyWithZone:(NSZone *)zone {
Person *p = [[Person alloc] init];
p.age = self.age;
p.name = self.name;
return p;
}

之后就不会报错,能正常的使用copy了。

但是在苹果官方文档上还说了一个注意事项:

If a subclass inherits NSCopying from its superclass and declares additional instance variables, the subclass has to override copyWithZone: to properly handle its own instance variables, invoking the superclass’s implementation first.

意思是:如果你的类可以产生子类,那么copyWithZone:方法将被继承,子类中也必须重写copyWithZone:方法,并且要先调用父类的copyWithZone:

这个时候在demo中增加一个Person的子类,并增加一个college属性,那么父类Person的copyWithZone:方法需要改为:

1
2
3
4
5
6
- (instancetype)copyWithZone:(NSZone *)zone {
Person *p = [[[self class] allocWithZone:zone] init];
p.age = self.age;
p.name = self.name;
return p;
}

同时在子类Student中可以这样实现:

1
2
3
4
5
6
7
8
9
10
11
@implementation Student

- (instancetype)copyWithZone:(NSZone *)zone {
Student *stu = [super copyWithZone:zone];
if (stu) {
stu.college = self.college;
}
return stu;
}

@end

如果实现一个类的copyWithZone:方法,而该类的超类也实现了协议,那么应该先调用超类的copy方法以复制继承来的实例变量,然后加入自己的代码以复制想要添加到该类中的任何附加的实例变量。


block中为什么要使用copy修饰?

在使用block作为属性的时候,通常使用的是copy

1
@property (copy) void (^clickBlock)(NSString * name);

使用copy修饰block其实是从MRC遗留下来的,在MRC时期,作为全局变量的block在初始化时是被存放在栈区的,这样在使用时如果block内有调用外部变量,那么block无法保留其内存,如果在出了block的初始化作用域内使用,就会引起崩溃,使用copy可以将block的内存推入堆中,这样让其拥有保存调用的外部变量的内存的能力。

在ARC下,对NSStackBLock用strong进行强引用的话,好像会自动对其进行copy一份,变成NSMallocBLock,所以不会crash。在ARC下,其实不使用copy修饰block也是可以的。

详细的block的实现可以参考唐巧关于block的讲解:谈Objective-C block的实现


blog