内存管理
对于这篇呢，其实现在都是ARC模式，正常状态下基本不用我们去手动释放内存，所以如果不是要面试呀、装逼或者扎实功底的，就先别看了或者了解下即可，因为像面试时，有些面试官想看你的基础时，就有些人会问，现在工作基本不会用到。
学习目标
1. 掌握内存管理的原理
2. 掌握手动内存管理
===============================================
1.需要理解的知识
1.1内存管理
1.1.1 C的内存管理，以及麻烦之处
char *p = (char *)malloc(100*sizeof (char));
这是C的动态内存分配，我们手动跟系统申请了100个字节的内存；或者说系统在堆里开辟了100个字节的空间，并将这个空间的首地址返回给指针变量p。
strcpy(p,"Hello World!");
将字符串拷贝给指针变量p指向的内存空间。
puts(p);
将p指针指向的内存空间里的字符串打印出来。
free(p);
使用完成后，手动跟系统释放内存空间；或者说系统回收空间。
如上就是C里简单的内存管理。
C的内存管理，我们手动申请，手动释放。这样来看，我们只需要注意两个问题就好了：
1，申请内存，使用完成后需要释放，如果不释放会造成内存泄露。
2，不能多次释放，如果多次释放，则会崩溃。
但是，如果项目比较复杂，需要有几十上百号人一起分工完成，就很容易出现问题。
比方说我们开辟了一块内存空间，里存放了一块很有用的数据。但是，这个数据不只有我在这一块代码里用，甚至有多个人，在程序的多个地方使用。这样造成的结果就是，就算我使用完成这块内存，我也不能去释放他，因为我不能确定，别人在别的地方是否还需要使用这块内存。内存泄露在所难免了。
OC的内存管理：
1.1.2 引用计数(retainCount)
对于一块动态申请的内存，有一个人（指针）使用，就给这个内存的计数器加1，使用完成后，就给这个计数器减1，当这个内存的引用计数为0了，我们再释放他，这样，上面的问题就解决了。OC，就是使用引用计数这种方式来管理内存的。
1.1.3 内存管理的黄金法则
对于引用计数来说，有一套内存管理的黄金法则:
The basic rule to apply is everything that increases the reference counter with alloc, [mutable]copy[withZone:] or retain is in charge of the corresponding [auto]release.
如果对一个对象使用了alloc、copy、mutablecopy、retain,new，那么你必须使用
相应的release或者autorelease。
通俗一点的说法就是谁污染谁治理。
1.1.4 objective-C的内存管理遵守下面这个简单的策略：
1.你拥有你创建的对象，也就是说创建的对象（使用alloc，new，copy或者mutalbeCopy等方法）的初始引用计数是1。
2.给对象发送retain消息后，你拥有了这个对象 ，retainCount+1
3.当你不需要使用该对象时，发送release或者autorelease消息放弃这个对象
4.不要对你不拥有的对象发送“放弃”的消息
1.1.4 MRC和ARC
ARC Automatic Reference Counting，自动引用计数，由xcode，帮我们去管理内存。
MRC Manual Reference Counting，手动引用计数，我们手动管理内存。
Xcode 5.0 版本以后默认是ARC模式，
1.1.5 如何将工程改为MRC
xcode5，工程创建的时候是ARC的，我们如果想要MRC，需要进行如下设置。
选中工程 - target - Bulid Settings -Automatic Reference Counting改为NO。
1.1.6 ARC执行了新的规则
● 开发者不能显示调用dealloc；不能实现和调用retain、release、retainCount和autorelease。
禁止使用@selector(retain),@selector(release)等等。
开发者仍可以实现dealloc方法，如果你想管理资源而不是变量。
ARC中自定义的dealloc方法，不需要调用[super dealloc]（其实这样做就会导致编译错误），编译器会强制自动链接到父类。
开发者仍可以对Core Foundation-style对象，使用CFRetain,CFRelease和其他相关方法。
● 开发者不能使用NSAutoreleasePool对象。ARC下使用@autoreleasepool，它比NSAtuoreleasePool更有效率。
为了配合手动引用计数，ARC的方法命名有限制：
● 访问器方法不能已new开头，反过来就是：开发者不能声明一个已new开头的属性，除非你给你指定一个getter
// 不正确
@property NSString *newTitle; // 正确
@property (getter=theNewTitle) NSString *newTitle;
1.1.7.野指针错误形式在Xcode中通常表现为：Thread 1：EXC_BAD_ACCESS(code=EXC_I386_GPFLT)错误。因为你访问了一块已经不属于你的内存。
2.需要记住的知识
2.1 alloc与release
创建一个Dog类
@interface Dog : NSObject
@end
@implementation Dog
- (void)dealloc
{
NSLog(@"dog dealloc");
[super dealloc];
}
@end
delloc里的析构函数，当对象销毁的时候，会自动调用这个方法，我们在这里重写这个方法。
在main函数里，写入如下代码：
int main(int argc, const char * argv[])
{
@autoreleasepool {
Dog *dog = [[Dog alloc] init];
}
NSLog(@"程序即将退出");
return ;
}
从终端打印信息来看，程序即将退出这条打印之前，已经打印dog dealloc，也就是说在程序运行结束前，dog对象已经销毁了。这个是ARC，由xcode帮我们管理dog对象。
将ARC改为MRC，再执行程序，dog对象并没有销毁，因为我们现在是手动管理了，我们需要遵守内存管理的黄金法则，Dog *dog = [[Dog alloc] init]; 我们需要对dog进行release。将main函数代码改为如下形式：
int main(int argc, const char * argv[])
{
@autoreleasepool {
Dog *dog = [[Dog alloc] init];
[dog release];
}
NSLog(@"程序即将退出");
return ;
}
再次执行程序，从打印可以看出，dog对象，已经销毁。这就是黄金法则，我们对dog进行alloc，就要对dog进行release。
注意，release 并不是销毁对象，让对象的引用计数减1，当对象的引用计数为0的时候，自动调用dealloc方法，销毁对象。
2.2 retain与retainCount
retain，将对象进行保留操作，也就是使对象的引用计数加1。
retainCount，打印一个对象的引用计数。
2.3 类的复合中使用
在上面代码中，增加Person类
@interface Person : NSObject {
// 一个人，养了一条狗（持有一条狗）
Dog *_dog;
}
- (void)setDog:(Dog *)dog;
- (Dog *)dog;
@end
@implementation Person
/* 版本1 （有问题） 人并没有真正持有狗，如果在main函数里[dog release]，让dog的引用计数减1，就变为0，dog就销毁了。
- (void)setDog:(Dog *)dog
{
_dog = dog;
}
*/
/* 版本2 （有问题） 如果人再持有别的狗，就会造成第一条狗得不到释放，内存泄露。
- (void)setDog:(Dog *)dog
{
_dog = [dog retain];
}
*/
/* 版本3 （有问题） 如果本来持有一条狗，又重新设置这条狗，先进行release，这个时候，很可能dog就销毁了，然后，就没法再次retain了。
- (void)setDog:(Dog *)dog
{
[_dog release];
_dog = [dog retain];
}
*/
// 版本4 OK!，标准写法
- (void)setDog:(Dog *)dog
{
if (_dog != dog) {
[_dog release];
_dog = [dog retain];
}
}
- (Dog *)dog
{
return _dog;
}
- (void)dealloc
{
NSLog(@"person dealloc");
// 人在销毁的时候，一并将持有的dog对象销毁
[_dog release];
[super dealloc];
}
//MRC:
黄金法则：
只要使用了alloc/retain/copy/mutableCopy,new, 创建了对象
那么就必须使用release进行释放，
———总结一句话就是：谁创建，谁负责释放
retain — 使对象的引用计数+1， 如果指针需要去持有这个对象
需要使用retain
retainCount: 返回对象的引用计数值
release : — 使对象的引用计数 -1， 而不是释放对象
dealloc：对象销毁的时候（也就是retainCount为0的时候）自动调用这个方法
MRC:
2.4 @property retain，assign，copy展开
2.4.1 retain展开
如上代码里，Person的setter和getter方法，也可以用property，写成如下形式
@property (nonatomic, retain) Dog *dog;
则会展开如下:
- (void)setDog:(Dog *)dog
{
if (_dog != dog)
{
[_dog release];
_dog = [dog retain];
}
}
2.4.2 assign展开
//简单数据类型 ，OC的内存管理对于简单的数据类型 int\float…,
@property (nonatomic, assign) Dog *dog;，assign是直接赋值，则会展开如下:
- (void)setDog:(QFDog *)dog
{
_dog = dog;
}
2.4.3 copy展开 , 复制一份原来的对象
//copy 多用于字符串
@property (nonatomic, copy)NSString *name;
展开如下：
- (void)setName:(NSString *)name
{
if (_name != name)
{
[_name release];
_name = [name copy];
}
}
2.4 字符串内存管理
2.4.1 字符串的内存管理
// 对于字符串而言，非常不遵守黄金法则! (如果从字符串的引用计数来看，乱七八糟!) 这只是一个表象! 其实内部还是遵循的!!
// 我们要做的是，我们依旧遵守我们的黄金法则!
因此，如果是NSString，我们的property格式写成如下: @property (nonatomic, copy) NSString *name;
2.4.2 copy和mutableCopy
2.5 数组的内存管理
结论
1）当我们创建数组的时候，数组会对每个对象进行引用计数加1
2）当数组销毁的时候，数组会对每个对象进行引用计数减1
3）当我们给数组添加对象的时候，会对对象进行引用计数加1
4）当我们给数组删除对象的时候，会对对象进行引用计数减1
总之，谁污染谁治理，管好自己就可以了（数组内部也遵守内存管理）。
2.6 autorelease与autoreleasepool
在main函数里写如下代码:
int main(int argc, const char * argv[])
{
@autoreleasepool {
Dog *dog = [[Dog alloc] init];
//dog并没有马上销毁，而是延迟销毁，将dog对象的拥有权交给了autoreleasepool
[dog autorelease];
//这个是可以打印的，因为打印完dog的引用计数后，dog对象才销毁
NSLog(@"retainCount = %lu",dog.retainCount);
}
NSLog(@"程序即将退出");
return ;
}
autoreleasepool相当于一个数组，如果哪个对象发送autorelease消息，实际将对象的拥有权交给了autoreleasepool；当autoreleasepool销毁的时候，autoreleasepool里持有的对象都发送一个release消息。
2.7 加方法的内存管理
我们用加方法创建的对象，不用我们release，是因为类内部的实现使用了autorelease，延迟释放
在Dog类的声明里增加一个加方法
+ (id)dog;
在Dog类的实现里进行实现
+ (id)dog
{
注意，这里不要写成release，如果是release，那么刚创建就销毁了，使用autorelease，使得将对象的拥有权交给了自动释放池，只要自动释放池没有销毁，dog对象也就不会销毁。
return [[[Dog alloc] init] autorelease];
}
2.8 对于自动内存释放简单总结一下：
- 1 autorelease方法不会改变对象的引用计数器，只是将这个对象放到自动释放池中；
- 自动释放池实质是当自动释放池销毁后调用对象的release方法，不一定就能销毁对象（例如如果一个 对象的引用计数器>1则此时就无法销毁）；
- 由于自动释放池最后统一销毁对象，因此如果一个操作比较占用内存（对象比较多或者对象占用资源比较多），最好不要放到自动释放池或者考虑放到多个自动释放池；
- ObjC中类库中的静态方法一般都不需要手动释放，内部已经调用了autorelease方法；
=====================================
ARC模式下的关键字：
__strong/__weak/__unsafe_unretain
开发者需要正确修饰变量。使用下面的格式来修饰变量声明。
类名* 修饰 变量名
例如：
MyClass * __weak myWeakReference;
MyClass * __unsafe_unretained myUnsafeReference;
对应的@property 参数分别为
strong/weak/unsafe_unretain
__strong ： 强引用，相当于MRC下的retain，指针对对象具有决定的占
有，默认情况。
__weak : 弱引用，指针对对象不具有决定的占有，相当于MRC下的
assign，对象释放后，指针赋值为nil。
__unsafe_unretain：弱引用，指针对对象不具有决定的占有，相当于MRC下的assign，对象释放后，指针为悬垂指针（不会赋值为nil）,可以会出现野指针，不建议使用。
@property(nonatomic, strong) xxx
//set 类似于 retain 展开 [name retain]
@property(nonatomic, weak) xxx
//类似于 assign
@property(nonatomic, unsafe_unretain) xxx
//类似于 assign