前言
世间万物中“一切皆对象”。我们知道在一个程序中，我们需要创建大量的对象，而创建对象时分配的是堆内存，并不会由系统释放。而在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 <Foundation/Foundation.h>
#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 <Foundation/Foundation.h>
#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 <Foundation/Foundation.h>
@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 <Foundation/Foundation.h>
#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 <Foundation/Foundation.h>
#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方法
