手动内存

为什么要内存管理？

因为内存一直被占用的话，内存最终会不够用。

内存管理好处，1G可以运行3G应用，只要使用时不超过1G，及时释放的话。

一.oc中采用“引用计数”（retainCount）方式管理对象所占内存（内存有指针指向的概念）。

1. alloc为对象分配内存。dealloc为对象释放所占内存，不能手动调用。
2. 使用alloc、new对象时，并将其引用计数器设为1，并拥有对象所有权。
3. copy制造一个副本，并将副本的引用计数设为1，对原有的引用计数不影响，并拥有副本对象所有权。
4. retain使引用计数加1，并拥有对象所有权。release使引用计数减1，并放弃对象所有权。
5. 当对象的retainCount为0时，系统自动调用dealloc释放对象内存；否则，分配内存将一直被占用。
6. autorelrease向NSAutoreleasepool注册。

二.

1. 引用计数：计内存的使用次数（内存被用了多少次）
2. 所有权对象分为：程序员和系统。谁retain，所有权归谁。　　NSString *sonCar = [mamaCar retain];//儿子有所有权,此时retain引用计数+1了,使用完后销毁不会出现野指针　　NSString *friendCar = sonCar;//朋友没有使引用计数加1,也就是说当引用计数为0，对象销毁的时候，会出现friendCar这个野指针
3. 消息（方法）是有延迟的，系统回收可能存在延迟，因为系统回收是以轮询的方式。就像现实中的保洁工人收垃圾。
4. 引用计数为0是打印不出来的，因为0代表没有该对象了，所以retain方法调用不出来，这时候系统只能打印出1。
5. 原则使用后立即释放。

三.属性中内存管理

1. 原则：一个类中，如果这个类有属性声明retain或者copy的属性，那么我们需要在这个类的dealloc方法里释放一次。
2. 属性内存管理分析图
3. 属性的赋值方式:

• 先初始化对象a
• b.a = a;
• [a release];

四.便利构造器内存管理

1. 通过使用autorelease延迟release来管理构造器的对象。return [对象 autorelease];或@autoreleasepool{}
2. NSAutoreleasePool自动释放池：

• 当创建的对象未来某个时候销毁时，可以使用对象的autorelease。
• 对象将所有权管理交给最近的NSAutoreleasePool对象，并由其全权管理。栈式结构（UINavigationController和图形上下文）
• 当池对象drain或release时，会逐一对池内对象发送release消息。
• 能不使用，尽量不使用aoturelease。知道什么时候用完，直接release。
• 任何OC对象只要调用autorelease方法，就会把该对象放到离自己最近的自动释放池中（栈顶的释放池）

五.检测工具

1. static Analyzer-Analysis Policy
2. product-》profile-》leaks

六.类中self点出来的属性。需要autorelease。dealloc中不用[_xxxx release]。

相反：_xxxx = [[**  alloc]init];的属性在dealloc中[_xxxx release];。不用autorelease。

---

 Teacher.h

@interface Teacher : NSObject
-(void)onClass;
@end

Teacher.m

#import "Teacher.h"

@implementation Teacher
-(void)onClass
{
    NSLog(@"teacher is on class");
}
@end

Student.h

#import "Teacher.h"
@interface Student : NSObject
{
    Teacher *_teacher;
}

//@property(nonatomic,retain)Teacher *teacher;
-(void)setTeacher:(Teacher *)aTeacher;
-(Teacher *)teacher;
@end

Student.m

#import "Student.h"

@implementation Student

//@synthesize teacher = _teacher;
//retain中@synthesize默认手动写法
-(void)setTeacher:(Teacher *)aTeacher
{
    if (_teacher != aTeacher)//旧对象不等于新对象的时候-赋新值
    {
        [_teacher release];//_teacher释放？第一次_teacher是nil(对nil release没影响)，但是如果后面还要把对象赋给_teacher的话，这里必须先释放（对上次传入的对象先进行释放并放弃所有权）
        _teacher = [aTeacher retain];//把所有权给_teacher。copy的话这里也改为[aTeacher retain]
        
    }
}
-(Teacher *)teacher
{
    return _teacher;
}



-(Student *)init
{
    self = [super init];
    if (self)
    {
        
    }
    return self;
}

//重写
-(void)dealloc
{
    [_teacher release];//属性中retain，这里也要release
    NSLog(@"我(%@)快要被释放了。。。。。",self);

　　[super dealloc];//第一步必须做的，保留父类释放

} @end

AppDelegate.m

 /*
    Student *s = [[Student alloc]init];
    NSLog(@"reatinCount = %d",s.retainCount);
    
    [s retain];
    NSLog(@"reatinCount = %d",s.retainCount);
    
    [s release];
    NSLog(@"reatinCount = %d",s.retainCount);
    
    [s release];
    NSLog(@"reatinCount = %d",s.retainCount);
    */
    //属性的内存管理
    Teacher *t = [[Teacher alloc]init];
    Teacher *t2 = [[Teacher alloc]init];

    Student *stu = [[Student alloc]init];
    stu.teacher = t;
    stu.teacher = t2;
    
    
    [t release];
    [t2 release];
    
    //sleep(10);//让系统休眠10秒
    
    [stu.teacher onClass];
    [stu release];
/*
    Student *s1 = [[Student alloc]init];
    Student *s2 = s1;
    NSLog(@"s2 = %d",s2.retainCount);
    [s2 retain];//2
    NSLog(@"s1 = %d",s1.retainCount);
    NSLog(@"s2 = %d",s2.retainCount);
    [s1 release];
    NSLog(@"s1 = %d",s1.retainCount);
    NSLog(@"s2 = %d",s2.retainCount);
*/

 

---

 

属性与构造器手动内存写法

AInstance.h

#import <Foundation/Foundation.h>

@interface AInstance : NSObject
{
    NSString *_name;
    int _age;
    int _cityCode;
}

-(void)setName:(NSString *)aName;
-(NSString *)name;

-(void)setAge:(int)aAge;
-(int)age;

-(void)setCityCode:(int)aCityCode;
-(int)cityCode;

-(AInstance *)initWithName:(NSString *)aName
             andAge:(int)aAge
        andCityCode:(int)aCityCode;

+(AInstance *)aInstanceWithName:(NSString *)aName
                  andAge:(int)aAge
             andCityCode:(int)aCityCode;

@end

AInstance.m

#import "AInstance.h"
@implementation AInstance
-(void)setName:(NSString *)aName
{
    if (_name != aName)
    {
        [_name release];
        _name = [aName retain];
    }
}
-(NSString *)name
{
    return _name;
}

-(void)setAge:(int)aAge
{
    _age = aAge;
}
-(int)age
{
    return _age;
}

-(void)setCityCode:(int)aCityCode
{
    _cityCode = aCityCode;
}
-(int)cityCode
{
    return _cityCode;
}

-(AInstance *)initWithName:(NSString *)aName
             andAge:(int)aAge
        andCityCode:(int)aCityCode
{
    self = [super init];
    if (self)
    {
        _name = aName;
        _age = aAge;
        _cityCode = aCityCode;
    }
    return self;
}

+(AInstance *)aInstanceWithName:(NSString *)aName
                  andAge:(int)aAge
             andCityCode:(int)aCityCode
{
    AInstance *ainstance = [[AInstance alloc]initWithName:aName
                                                   andAge:aAge
                                              andCityCode:aCityCode];
    return [ainstance autorelease];
}


- (void)dealloc
{
    [_name release];
    
    [super dealloc];
}
@end

AppDelegate.m

AInstance *a = [[AInstance alloc ]initWithName:@"jobs"
                                           andAge:19
                                      andCityCode:20];
    NSLog(@"%@",a.name);
    [a release];  

2.

NSAutoreleasePool

/*任何OC对象只要调用autorelease方法，就会把该对象放到离自己最近的自动释放池中（栈顶的释放池）*/
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];
    for (int i = 0; i < 1000000; i++)
    {
        NSMutableString *str = [[NSMutableString  alloc]init];
        [str autorelease];
        if (i%1000 == 0)
        {
            [pool release];/*该程序每执行1000次，就把池子销毁，
                            也就是str在自动释放池累积的对象不会超过1000个*/
            
            pool = [[NSAutoreleasePool alloc]init];//同时新建一个池子
        }
    }
    [pool release];