Objective-C 手动管理内存

前言

世间万物中“一切皆对象”。我们知道在一个程序中，我们需要创建大量的对象，而创建对象时分配的是堆内存，并不会由系统释放。而在Objctive-C中并没有像其他语言一样的垃圾回收的机制，这样一来就需要我们手动去做内存管理。有一个好消息就是在Xcode4.1版本之后，苹果给引入了ARC（Automatic Reference Counting）机制，这就极大的方便了开发人员的工作。但是为了更好的理解Objective-C的内存管理机制，我将关闭ARC机制，进行手动的内存管理。

Objective-C 内存管理原理

ObjC中内存的管理是依赖于对象引用计数器来进行的：在ObjC中每个对象都有自己的引用计数器，是用一个整数（retainCount,[Unsigned long]）
来表示对象被引用的次数，即现在多少东西正在使用这个对象。当对象刚被创建时，默认计数器为1，当计数器的值为0时，调用对象的dealloc方法，销毁对象。任何自己创建的对象都归自己所有，可以使用 alloc new copy 的方法创建对象，可以用retain来获得一个对象的所有权。当一个对象的引用计数器为0时，销毁对象，其占用的内存被系统回收，那么它所占据的内存空间将不再可用，如果坚持使用则会造成野指针，可能会造成不可预知的错误（可以将野指针指向nil）。

下面可以通过一些例子来理解内存管理。
(属性—Build Settings-搜索“auto”找到Objective-C Automatic Reference Counting 设置成No。)

首先创建一个Person类，在Person类中重写dealloc方法。

//  Person.m
//  MemoryManagement
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import "Person.h"

@implementation Person
-(void)dealloc{

    NSLog(@"dealloc 方法被调用，Person销毁");
    [super dealloc];
}
@end

//  main.m
//  Memory Management foundation
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import 
#import"Person.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //用Person类实例化一个对象
        
        Person *p = [Person new];
        //对象的retainCount+1
        NSUInteger count = [p retainCount];
        
        NSLog(@"count = %lu",count);
        //对象的retain再加1
        Person *p2 = [p retain];
        NSLog(@"p2.retainCount = %lu",[p2 retainCount]);
        //对象的retainCount-1
        [p release];
        NSLog(@"p.retainCount = %lu",[p retainCount]);
        //对象的retaiCount-1，调用dealloc方法
        [p release];
        //对象内存被释放，防止野指针错误。把p设为nil。
        p = nil;
       
    }
    return 0;
}

单个对象的内存管理

//  Yuanyue.m
//  MemoryManagement
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import "Yuanyue.h"

@implementation Yuanyue
-(void)eat{
    
    NSLog(@"我在吃零食");

}
-(void)dealloc{
    NSLog(@"y已经销毁。");
    [super dealloc];
}
@end

//  main.m
//  一个对象的内存管理
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import 
#import "Yuanyue.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //创建一个对象
        Yuanyue *y = [[Yuanyue alloc]init];
        [y eat];
        NSLog(@"y.retainCount = %lu",y.retainCount);
        //释放内存空间,调用了dealloc方法
        [y release];
        
        //可是释放了内存空间，仍然可以调用eat方法，这就是僵尸对象了，在项目中的 Enable zombie objects 开启僵尸对象检测，这样再调用对象的eat方法系统就会报错。
        [y eat];
        
        //运行结果
        /*
**2016-04-23 22:57:20.622 ****一个对象的内存管理****[30367:320445] ****我在吃零食**
**2016-04-23 22:57:20.623 ****一个对象的内存管理****[30367:320445] y.retainCount = 1**
**2016-04-23 22:57:20.623 ****一个对象的内存管理****[30367:320445] y****已经销毁。**
**2016-04-23 22:57:20.623 ****一个对象的内存管理****[30367:320445] *** -[Yuanyue eat]: message sent to deallocated instance 0x1002002e0**
         */
        
    }
    return 0;
}

对象之间有时候会交叉引用，这时候就有一个原则：“谁创建，谁释放”。

多个对象的内存管理

//  Car.h
//  MemoryManagement
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import 

@interface Car : NSObject
{
    //定义实例变量
    int _speed;
}
//声明一个方法
-(void)run;

-(void)setSpeed:(int) speed;

@end

//  Car.m
//  MemoryManagement
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import "Car.h"

@implementation Car

-(void)dealloc{

    NSLog(@"车子坏了");
    [super dealloc];
}

-(void)run{
    
    NSLog(@"车以%d的速度向前运行去合肥",_speed);

}

-(void)setSpeed:(int) speed{
    
    _speed = speed;

}

@end

//  Person.h
//  MemoryManagement
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import 
#import "Car.h"

@interface Person : NSObject
{
    //对象之间的关系：组合、依赖、关联
    Car *_car;//实例变量_car  和Person的关系是关联

}

-(void)goHefei;

-(void)setCar:(Car *)car;

@end

//  Person.m
//  MemoryManagement
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import "Person.h"

@implementation Person

-(void)dealloc{
    NSLog(@"我走了");
    [_car release];
    [super dealloc];

}
-(void)goHefei{
    
    [_car run];

}
-(void)setCar:(Car *)car{
    
    _car = [car retain];
    
}

@end

//  main.m
//  多个对象的内存管理
//
//  Created by 袁跃 on 16/4/23.
//  Copyright © 2016年 iflytek. All rights reserved.
//

#import 
#import "Person.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //创建Person对象
        Person *yuanyue = [Person new];
        //创建一个车的对象奥迪Audi
        Car *Audi = [Car new];
        //给实例变量赋值
        Audi.speed = 120;
        //给yuanyue set一个车的对象
        [yuanyue setCar:Audi];
        //调用yuanyue的goHefei的方法
        [yuanyue goHefei];
        //释放内存
        [Audi release];
        //释放内存
        [yuanyue release];
        Audi = nil;
       yuanyue = nil;
       
    }
    return 0;

    //运行结果
    /*
     
     2016-04-23 23:42:45.734 多个对象的内存管理[31401:349296] 车以120的速度向前运行去合肥
     2016-04-23 23:42:45.734 多个对象的内存管理[31401:349296] 车子坏了
     2016-04-23 23:42:45.734 多个对象的内存管理[31401:349296] 我走了
     */

基本数据类型的数据作为实例变量
int _speed;
//set方法的写法
    -(void)setSpeed:(int)speed{
        _speed = speed;
}

假如人养了一条狗；
Dog* _dog;
对于对象作为另外一个类的实例变量
-(void)setDog:(Dog*)dog{
        //判断对象是否是原对象
        if(_dog != dog){
                [_dog release];//release 旧值
                _dog = [dog retain];//retain 新值，赋值给实例变量
        }
}
我们通过[dog retain]来让每次赋值时对象的引用计数器retainCount+1，这样就能保证人在销毁前
人的dog不会被释放，且上一轮的赋值对象能够正常释放。最后在Person类的dealloc方法中对_dog 
进行一次释放，（在set方法中做了一次retain），保证_dog能正常的回收。

@property参数

用@property进行自动实现：例如下例

@property int age; (.h)
*1. 生成_age
*2. 生成_age的get和set方法的声明
*3. 实现_age的get和set方法