iOS之copy、strong使用，block特性

身边一同事，我印象在过去三个月，有两次因为使用“copy”修饰UIKit控件的属性，导致程序崩溃。他还一本正经的说我以前一直使用copy。

好了，到这里我们就不得不说说什么时候使用copy。我的印象中，只有两处使用了copy，即修饰NSString类型与block，其他的都是使用strong关键字修饰。

说到这里，我们先来说说NSString类型，我在创建的NSString类型的属性中，也曾也使用过strong修饰的，因为我几乎没有使用过NSMutableString类型转换，我不用去考虑是用copy还是strong更好，当然为了代码的健壮使用copy更好，一下我就作具体分析缘由。

在MRC中，使用retain，copy进行拷贝，会使retainCount结果+1.但是如果是深拷贝，便会改变指针，retainCount = 1；下面我直接在ARC下调试，我只关心内存指针，不关心retainCount。

NSString *str0 = @"a";

NSLog(@"str0内存地址： %p",str0);    //0x107fcb088   在64位系统上得到的内存地址较短，说明存放在常量区（代码，常量，全局，堆，栈）

NSString *string0  = [str0 copy];

NSLog(@"string0的内存地址： %p",string0);   //0x107fcb088  浅拷贝

NSString *str = [NSString stringWithFormat:@"%@",@"a"];

NSLog(@"str内存地址： %p",str);   //0xa000000000000611  （栈区）

NSString *string  = [str copy];

NSLog(@"string的内存地址： %p",string);   //0xa000000000000611  浅拷贝

NSMutableString *str1 = [NSMutableString stringWithFormat:@"a"];

NSLog(@"str1的内存地址：%p",str1);   //0x60000007c5c0

NSMutableString *string1 = [str1 copy];

NSLog(@"string1的内存地址： %p",string1);   //0xa000000000000611   内存地址发生了改变，进行了深拷贝，而且跟上面的地址一样

总结：对于NSString类型只是引用了内存，浅拷贝；NSMutableString作为NSString的子类进行copy才是深拷贝。

刚刚上面的深拷贝，出现跟浅拷贝一样的地址，不由得我们需要多做两个测试，如下：

NSMutableString *strEx = [str mutableCopy];

NSLog(@"strEx的内存地址：%p",strEx);    //0x608000263040 深拷贝

NSMutableString *strExCopy = [str mutableCopy];

NSLog(@"strExCopy的内存地址：%p",strExCopy); //0x60000026a440    str两次mutableCopy的地址不一样

NSMutableString *stringEx = [strEx copy];

NSLog(@"stringEx的内存地址： %p",stringEx);   //0xa000000000000611 与上面地址一样

NSMutableString *stringEx1 = [strExCopy copy];

NSLog(@"stringEx1的内存地址： %p",stringEx1); //这个也是0xa000000000000611，说明两次copy都指向同一个地址

NSMutableString *strExEx = [strEx mutableCopy];

NSLog(@"strExEx的内存地址：%p",strExEx);     //0x600000073d00 深拷贝

结论：可以看成，str1所谓的“深拷贝”，其实不是“深拷贝”，它还是拷贝了之前的地址。这样，我得出，当进行mutable创建，其实是系统首先创建了一份NSString的地址，然后再深拷贝，相当于[NSMutableString stringWithFormat:@"a"]；来自于 [str mutableCopy]；。

在字符串类型NSString中使用strong还是copy，到底哪个更好，苹果自己的API中告诉了我，copy更好，那么我们就进一步进行验证。首先我们创建两个字符串对象分别为strong与copy修饰的，然后再进行赋值比较，如下。

@property (strong,nonatomic)NSString *testStr;

@property (copy,nonatomic)NSString *testStrCopy;

- (void)viewDidLoad {

[super viewDidLoad];

NSString *testStr = [NSString stringWithFormat:@"%@",@"a"];

NSLog(@"testStr内存地址： %p",testStr); //0xa000000000000611

self.testStr = testStr;

NSLog(@"self.testStr内存地址： %p",self.testStr);//0xa000000000000611   浅拷贝

self.testStrCopy = testStr;

NSLog(@"self.testStrCopy内存地址： %p",self.testStrCopy);//0xa000000000000611  浅拷贝

NSMutableString *testStr1 = [NSMutableString stringWithFormat:@"%@",@"a"];

NSLog(@"testStr1内存地址： %p",testStr);  //0x608000078a00  与上面的str1 0x60000007c5c0也不一样，MutableCopy是重新创建了地址

self.testStr = testStr1;

NSLog(@"self.testStr内存地址： %p",self.testStr);//0x608000078a00 strong指向同一个地址

self.testStrCopy = testStr1;

NSLog(@"self.testStrCopy内存地址： %p",self.testStrCopy);//0xa000000000000611 虽然地址变了，但还是指向原来的地址

}

总结：对于NSString类型，使用copy修饰，不会改变它原有的类型，strong会指向引用的对象，有可能改变其类型状态，所以copy能增强NSString的健壮性----------------用下面一张图表示

block特性

另一个使用copy的地方就是修饰block，对于我们现在都使用ARC模式来说，我觉得使用strong或者copy都是可以的，下面用事例说明：

@property (nonatomic,copy)void(^demoBolck)();

@property (nonatomic,strong)void(^demoBolck1)();

int b=8;

void (^demoBolck)() = ^{

NSLog(@"demoBolck");

};

NSLog(@"demoBolck %@",demoBolck);    //<__NSGlobalBlock__: 0x1085af0e0>  无论ARC还是MRC下，因不访问外部局部(包括无外部变量或者只有全局变量)，NSGlobalBlock表示在全局区

void (^demoBolck4)() = ^{

NSLog(@"demoBolck4  %d",b);

};

NSLog(@"demoBolck4 %@",demoBolck4);    //<__NSGlobalBlock__: 0x10150b120>  全局区

__block int a = 6;   //block内部引用a，并修改其值，需要用block修饰，不然可以不用。不过是引用行属性，需要

void (^demoBolck2)() = ^{

NSLog(@"demoBolck2 %d",a++);

};

demoBolck2();

NSLog(@"demoBolck2 %@,%d",demoBolck2,a);   //<__NSMallocBlock__: 0x600000056c50> ARC下堆区  <__NSStackBlock__: 0x7fff5d0ada28>MRC下在栈区

NSLog(@"demoBolck2.Copy %@",[demoBolck2 copy]);    //<__NSMallocBlock__: 0x600000056c50>copy操作不管MRC或者ARC都在堆区，只是在MRC下进行copy会改变地址

self.demoBolck = demoBolck2;

NSLog(@"self.demoBolck %@",self.demoBolck);

self.demoBolck1 = demoBolck2;

self.demoBolck1();     //demoBolck2  7   能执行无问题

NSLog(@"self.demoBolck1 %@",self.demoBolck1);     //<__NSMallocBlock__: 0x600000056c50>  strong修饰并没有问题

总结：在 Objective-C 语言中，一共有 3 种类型的 block：

1. _NSConcreteGlobalBlock 全局的静态 block，不会访问外部局部变量。
2. _NSConcreteStackBlock 保存在栈中的 block，当函数返回时会被销毁。
3. _NSConcreteMallocBlock 保存在堆中的 block，当引用计数为 0 时会被销毁。

关于block的知识，参考http://blog.devtang.com/2013/07/28/a-look-inside-blocks/