copy和mutableCopy
- 使用copy功能的前提
- 需要遵守NSCopying协议,实现copyWithZone:方法
@protocol NSCopying
- (id)copyWithZone:(NSZone *)zone;
@end
- 使用mutableCopy的前提
- 需要遵守NSMutableCopying协议,实现mutableCopyWithZone:方法
@protocol NSMutableCopying
- (id)mutableCopyWithZone:(NSZone *)zone;
@end
- 系统自带的类默认遵守了NSMutableCopying和NSCopying协议了,所以不需要手动写出来。如果是自己自定义类,那么必须手动遵守协议,才可以调用copy和mutableCopy方法
自定义类实现copy和mutableCopy
main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
/*
1.以后想让自定义的对象能够被copy只需要遵守NSCopying协议
2.实现协议中的- (id)copyWithZone:(NSZone *)zone
3.在- (id)copyWithZone:(NSZone *)zone方法中创建一个副本对象, 然后将当前对象的值赋值给副本对象即可
*/
Person *p = [[Person alloc] init];
p.age = 24;
p.name = @"zb";
NSLog(@"%@", p);
// 调用copyWithZone:方法
Person *p2 = [p copy];
// 调用mutableCopyWithZone:方法
//Person *p2 = [p mutableCopy];
NSLog(@"%@", p2);
return 0;
}
Person.h文件
#import <Foundation/Foundation.h>
@interface Person : NSObject<NSCopying, NSMutableCopying>// 遵守两个协议
@property (nonatomic, assign) int age;
@property (nonatomic, copy) NSString *name;// 字符串用copy修饰
@end
Person.m文件
#import "Person.h"
@implementation Person
- (id)copyWithZone:(NSZone *)zone
{
// 1.创建一个新的对象
Person *p = [[[self class] allocWithZone:zone] init];
// 2.设置当前对象的内容给新的对象。将_age,_name赋值给p.age , p.name
p.age = _age;
p.name = _name;
// 3.返回新的对象
return p;
}
/*
- (id)mutableCopyWithZone:(NSZone *)zone
{
// 1.创建一个新的对象
Person *p = [[[self class] allocWithZone:zone] init];
// 2.设置当前对象的内容给新的对象
p.age = _age;
p.name = _name;
// 3.返回新的对象
return p;
}
*/
浅拷贝(shallow copy,指针拷贝)和深拷贝(deep copy,内容拷贝)
- 1.通过copy,mutableCopy的方式拷贝对象内容,无论是深拷贝还是浅拷贝,拷贝出来的对象的内容和之前的内容一模一样,注意哦,仅仅是内容
- 2.如果拷贝之后两个对象都是不可变类型的,那么两个对象的地址一样->浅拷贝。不可变类型的对象,那么对象中的内容也不可修改。
- 3.如果拷贝之后两个对象的类型不同,那么两个对象的地址不一样(不是同一个对象了)->深拷贝。此时如果你修改其中一个的对象内容,不会影响另一个对象的内容。就像拷贝xcode文件一样,修改其中一个xocde文件中的代码,另一个xcode文件中的代码不会受到影响
- 4.综合2和3的总结:浅拷贝:拷贝之后,两个对象的内容,不可修改;深拷贝:拷贝之后,两个对象的内容,可以修改,但修改其中一个对象的内容,不会影响另一个对象的内容
- 5.调用copy方法,会生成不可变类型的对象。不可变类型:NSString、NSArray、NSDictionary
- 6.调用mutableCopy方法,会生成可变类型的对象。可变类型:NSMutableString、NSMutableArray、NSMutableDictionary
浅拷贝和深拷贝的内存管理
- 1.浅拷贝:不会生成新的对象,但是系统会对原来的对象进行retain,所以需要对原来的对象str1进行一次release操作
char *cstr = "this is a c string";
NSString *str1 = [[NSString alloc] initWithUTF8String:cstr];
// str1对象的引用计数器为1
NSLog(@"str1 = %lu", [str1 retainCount]);// 1
NSString *str2 = [str1 copy];
// 结果为2,说明浅拷贝确实对原来的对象str1进行了retain操作
NSLog(@"str1 = %lu", [str1 retainCount]); // 2
[str1 release];
- 2.深拷贝:会生成新的对象,系统不会对原来的对象进行retain,只会对新生成的对象进行retain,所以需要对新的对象str2进行一次release操作
char *cstr = "this is a c string";
NSString *str1 = [[NSString alloc] initWithUTF8String:cstr];
NSLog(@"str1 = %lu", [str1 retainCount]);// 1
NSMutableString *str2 = [str1 mutableCopy];
// 结果为1,说明上面的mutableCopy操作没有对str1对象的进行引用计数器+1,而是对str2对象的引用计数器+1
NSLog(@"str1 = %lu", [str1 retainCount]);// 1
// 结果为1,说明,确实mutableCopy确实是对str2对象进行了引用计数器+1
NSLog(@"str2 = %lu", [str2 retainCount]);// 1
[str2 release]; // 0 必须对新拷贝的对象str2做一次release
[str1 release]; // 0 之前的对象引用计数器为1,也必须进行一次release操作
copy的用途
- 1.声明字符串属性都用copy修饰.
这样外界进行深拷贝时,就会创建新的对象,这样外界修改了字符串属性的值,影响的只是新的对象,并不会影响原来的对象 - 2.声明block属性都用copy修饰.
避免以后调用block来执行{}中的内容时,内容中使用到的外界对象已经释放了,那么程序就会崩掉的情况。调用的对象已经被释放了,就是僵尸对象,野指针。
- 问题:声明block属性用copy修饰.这样可以保住block中使用外界对象的命,即使外界的对象已经被释放,block也会让这个对象复活,为什么?
- 回答:对block进行一个copy操作,block会转移到堆中,此时,block可以访问外界的对象p,会执行retain+1的操作。因为如果不用copy,那么外界的对象的引用计数器为0的话,block中使用这个对象就会崩掉,如果用了copy,会对这个0进行retain+1,那么block使用这个对象时肯定不会崩掉,但是我们还必须手动利用 Block_release(block);把这个对象释放掉
注意点:用 __block解决 copy和block之间的循环引用(内存泄露、你的指针强引用我,我的指针又强引用着你)
- 适用情况:对象中用到了block,而block的{}中又用到了对象,彼此相互引用,通过将对象用__block修饰来解决说明原因:因为用__block修饰,哪怕block在堆中,也不会对外界的对象进行retain+1操作.不retain+1,也就是说block的指针不指向外界的对象,所以不会造成循环引用,这时仅仅是外界对象的指针指向了block,这是单方向的引用,不会造成循环引用。
-
循环引用的代码:
Person *p = [[Person alloc] init]; // p指针强引用着pBlock p.pBlock = ^{ NSLog(@"name = %@", p.name); // pBlock指针强引用着p }; p.pBlock();
利用__block解决循环引用:
__block Person *p = [[Person alloc] init];
// p指针强引用着pBlock
p.pBlock = ^{
NSLog(@"name = %@", p.name); // pBlock指针不会对p对象进行retain+1操作,也就不会强引用着对象p
};
p.pBlock();