Objective-C的内存管理（一）黄金法则的理解

转自：http://blog.csdn.net/lonelyroamer/article/details/7666851

一、内存管理黄金法则：

The basic rule to apple is everything thatincreases the reference counter with alloc,[mutable]copy[WithZone:] or retainis in charge of the corresponding [auto]release.

如果一个对象使用了alloc，[mutable] copy，retain，那么你必须使用相应的release或autonrelease

二、内存管理类型分类

基本类型和C语言的类型：如：

int,short,char,struct,enum,union等类型

OC类型：任何继承于NSObject对象都属于OC的类型。

我们讲的内存管理实际上是对OC类型的内存管理，它对基本数据类型和C语言的类型并不管用。

三、C和C＋＋内存管理的不足

如上，又3个引用指向了这一块内存，任何一个调用了free方法释放这个内存，而其余的引用在不知道的情况下继续使用这块内存的时候，就会出现问题。何时由谁去释放这块内存，这就是C和C++在内存管理上的混乱。

四、OC对象在内存中的结构

所有的OC类型的对象的结构如下，这个对象的内存在包含自己的变量和方法的基础上，还有一个包含retainCount的引用计数。

每一个OC对象都有一个4个字节的retainCount的计数器。表示当前对象被引用的计数。如果计数为0，那么就真正的去释放这个对象。

规则：

1、Objective-C类中实现了引用计数器，对象知道自己当前被引用的次数

2、最初对象的计数器为1

3、如果需要引用对象，可以给对象发送一个retain消息，这样对象的计数器就加1

4、当不需要引用对象了，可以给对象发送release消息，这样对象计数器就减1

5、当计数器减到0，自动调用对象的dealloc函数，对象就会释放内存

6、计数器为0的对象不能再使用release和其他方法

五、举例说明

比如有一个引擎类Engine，有一个汽车类Car，Car里面有一歌Engine的实例变量，一个setter和getter方法。具体如下

1. #import "Car.h"
2. @implementation Car
3. -(void)setEngine:(Engine*) engine
4. {
5. _engine=engine;
6. }
7. -(Engine*)engine
8. {
9. return _engine;
10. }
11. -(void)dealloc
12. {
13. NSLog(@"Car is dealloc");
14. [super dealloc];
15. }
16. @end

上面写的是一个简单的类，当让这样写是有问题，所以需要一步步的改进。

第一步改进：

先使用它看问题的所在,在main方法里面如下使用：

1. //先创建一个引擎
2. Engine* engine1=[[Engine alloc]init];
3. [engine1 setID:1];
4. //在创建一个汽车，设置汽车的引擎
5. Car* car=[[Car alloc]init];//retainCount=1
6. [car setEngine:engine1];
7. /*分析：在这里，现在有两个引用指向这个Engine对象，engine1和Car中的_engine,可是这个Engine对象的引用计数还为1，因为在
8. set方法中，并没有使用retain。那么不管是哪个引用调用release，那么另外一个引用都会指向一块释放掉的内存，那么肯定
9. 会发生错误。所以需要在set方法中加以改进。*/

第二步改进：

setter方法改进

1. -(void)setEngine:(Engine*) engine
2. {
3. _engine=[engine retain];//多了一个引用，retainCount+1
4. }

再在main中使用它

1. //先创建一个引擎
2. Engine* engine1=[[Engine alloc]init];
3. [engine1 setID:1];
4. //在创建一个汽车，设置汽车的引擎
5. Car* car=[[Car alloc]init];//retainCount=1
6. [car setEngine:engine1];//retainCount=2，因为使用了retain，所以retainCount=2，
7. //假设还有一个引擎
8. Engine* engine2=[[Engine alloc]init];
9. [engine2 setID:2];
10. //这个汽车要换一个引擎，自然又要调用settr方法
11. [car setEngine:engine2];
12. /*分析：在这里，汽车换了一个引擎，那么它的_engine就不在指向engine1的哪个对象的内存了，而是换成了engine2，也就是说engine1的哪个对象指向的内存的引用只有一个
13. 可是它的retainCount是两个，这就是问题的所在了。所以仍然需要改进*/

第三步改进：

1. -(void)setEngine:(Engine*) engine
2. {
3. [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉
4. _engine=[engine retain];//多了一个引用，retainCount+1
5. }

再在main'中使用

1. //先创建一个引擎
2. Engine* engine1=[[Engine alloc]init];
3. [engine1 setID:1];
4. //在创建一个汽车，设置汽车的引擎
5. Car* car=[[Car alloc]init];//retainCount=1
6. [car setEngine:engine1];//retainCount=2，因为使用了retain，所以retainCount=2，
7. //如果进行了一个误操作，又设置了一次engine1
8. [car setEngine:engine1];
9. /*分析：那么，又要重新调用一次setter方法，这根本就是无意义的操作，浪费资源，所以要在设置之间加上判断*/

第四步改进：

1. -(void)setEngine:(Engine*) engine
2. {
3. if(_engine!=engine){//判断是否重复设置
4. [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉
5. _engine=[engine retain];//多了一个引用，retainCount+1
6. }
7. }

第五步：

现在setter方法基本没有问题了，那么在当我们要释放掉一个car对象的时候，必须也要释放它里面的_engine的引用，所以，要重写car的dealloc方法。

1. -(void)dealloc
2. {
3. [_engine release]; //在释放car的时候，释放掉它对engine的引用
4. [super dealloc];
5. }

这还不是最好的释放的方法，下面的方法更好

1. -(void)dealloc
2. {
3. [_engine setEngine:nil]; //在释放car的时候，对setEngine设置为nil，它不仅会release掉，并且指向nil，即使误操作调用也不会出错。
4. [super dealloc];
5. }

所以，综上所述，在setter方法中的最终写法是

1. -(void)setEngine:(Engine*) engine
2. {
3. if(_engine!=engine){//判断是否重复设置
4. [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉
5. _engine=[engine retain];//多了一个引用，retainCount+1
6. }
7. }

然后在dealloc方法中写法是：

1. -(void)dealloc
2. {
3. [_engine setEngine:nil]; //在释放car的时候，对setEngine设置为nil，它不仅会release掉，并且指向nil，即使误操作调用也不会出错。
4. [super dealloc];
5. }

六、property中的setter语法关键字

在property属性中有三个关键字定义关于展开setter方法中的语法，assgin(缺省)，retain，copy。当然这三个关键字是互斥的。

1、assgin展开stter的写法

1. -(void)setEngine:(Engine*) engine
2. {
3. _engine=engine;
4. }

2、retain展开的写法

1. -(void)setEngine:(Engine*) engine
2. {
3. if(_engine!=engine){//判断是否重复设置
4. [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉
5. _engine=[engine retain];//多了一个引用，retainCount+1
6. }
7. }

3、copy展开的写法

1. -(void)setEngine:(Engine*) engine
2. {
3. if(_engine!=engine){//判断是否重复设置
4. [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉
5. _engine=[engine copy];//多了一个引用，retainCount+1
6. }
7. }

对于copy属性有一点要主要，被定义有copy属性的对象必须要符合NSCopying协议，并且你还必须实现了-(id)copyWithZone:(NSZone*)zone该方法。

可以看到，使用retain和我们上面举得例子完全相同，所以我们可以使用property和它的retain代替之前的写法。