IOS开发基础Object-C（08）—OC内存管理（2）-对象之间的内存管理

前几天，我们学习了内存管理的基本知识，了解了内存管理的基本原理。那么，今天我们来学习一下对象之间的内存管理，看看对象之间是如何进行内存管理的。首先，我们新建两个类：Student和Book类，在Student类中声明一个Book对象

Student.h

#import <Foundation/Foundation.h>  
#import "Book.h"  

@interface Student : NSObject  
{  
    int age;  
    Book *book;  
}  
  
@property int age;  
  
- (id) initWithAge:(int)_age;  
@property Book *book;  
  
@end 

Student .m

#import "Student.h"  
  
@implementation Student  
  
@synthesize age, book;//在Xcode4.5及以后的版本中，这一句可以省略，编译器会自动实现getter和setter方法  
    
#pragma mark 构造方法  
- (id)initWithAge:(int)_age{  
    if(self = [super init])  
        age = _age;  
      
    return self;  
}  
  
#pragma mark 回收对象  
- (void)dealloc{  
      
    NSLog(@"student %i 被销毁了", age);  
      
    [super dealloc];  //不要忘了这一句，而且是放在最后的。

}  
  
  
@end  

我们再来进行Book类的声明与实现

Book.h

#import <Foundation/Foundation.h>  
  
@interface Book : NSObject  
{  
    float price;  
}  
  
@property float price;  
  
- (id)initWithPrice:(float)_price;  
  
  
@end  

Book.m

#import "Book.h"  
  
@implementation Book  
  
@synthesize price;//在Xcode4.5及以后的版本中，这一句可以省略，编译器会自动实现getter和setter方法  
  
- (id)initWithPrice:(float)_price{  
    if(self = [super init])  
        price = _price;  
      
    return self;  
}  
  
- (void)dealloc{  
    NSLog(@"book %f 被销毁了", price);  
      
    [super dealloc];}  
  
@end  

main.m

#import <Foundation/Foundation.h>  
#import "Student.h"  
#import "Book.h"  
  
int main(int argc, const char * argv[])  
{  
  
    @autoreleasepool {  
          
        Student *stu=[[Student alloc]initWithAge:10];
        Book *book=[[Book alloc]initWithPrice:3.5];
        stu.book=book;

        [book release];
        [stu release];
    }  
    return 0;  
}  

运行结果：

2015-10-21 16:17:58.316 对象之间的内存管理[2049:303] book 3.500000被销毁了

2015-10-21 16:17:58.318 对象之间的内存管理[2049:303] student 10被销毁了

似乎没有什么问题，Student和Book都被释放了。但是真的没有什么问题吗？在实际开发中，我们通常把一些功能抽出来单独写一个方法。比如我们现在加一个test方法把Book的功能抽出来，大家再看看有没有什么问题。

#import <Foundation/Foundation.h>  
#import "Student.h"  
#import "Book.h"  
  
void test(Student *stu){  
    Book *book = [[Book alloc] initWithPrice:3.3];  
    stu.book = book;  
      
}  
  
  
  
int main(int argc, const char * argv[])  
{  
  
    @autoreleasepool {  
          
        Student *stu = [[Student alloc] initWithAge:10];  
          
        test(stu);  
          
        [stu release];  
          
    }  
    return 0;  
}  

大家有没有发现问题？那我们再来运行一下

2015-10-21 16:27:58.396 对象之间的内存管理[2349:303] student 10被销毁了

出现内存泄露了，book对象没有被释放，也就是说，book没有被release

那么有同学就会说了，在test方法中，在

stu.book=book;

后面加上一个

[book release];

不就可以解决了吗？好像也没有什么问题，也没有违背内存释放的原则（谁创建谁释放）。如果再增加一个新的需求，我们再给Student类增加一个方法叫readBook( ),用于打印出学生当前读的书的价格。新建一个test1()方法，调用readBook()方法，然后再在main函数中调用 test1() 。我们来看一下

在Student.h文件中声明

-(void)readBook;

在Student.m文件中实现

#pragma  mark 读书  
- (void)readBook{  
    NSLog(@"当前读的书的价格是：%f",book.price);  //注意，这里调用了book.prise
} 

mian.m函数修改如下：

#import <Foundation/Foundation.h>  
#import "Student.h"  
#import "Book.h"  
  
void test(Student *stu){  
    Book *book = [[Book alloc] initWithPrice:3.3];  
    stu.book = book;  
      
    [book release];  
      
}  
  
void test1(Student *stu){  
    [stu readBook];  
}  
  
  
  
int main(int argc, const char * argv[])  
{  
  
    @autoreleasepool {  
          
        Student *stu = [[Student alloc] initWithAge:10];  
          
        test(stu);  
          
        test1(stu);  
          
        [stu release];  
          
    }  
    return 0;  
}  

注意：

[stu readBook];

调用的是

#pragma  mark 读书  
- (void)readBook{  
    NSLog(@"当前读的书的价格是：%f",book.price);  //注意，这里调用了book.prise
} 

介绍这里大家有没有看出问题，是不是出现了问题？在test()中，我们已经把book释放了，但是在test1()中，我们调用了readBook()方法，再次调用了book.price。既然book对象已经释放了，已经不存在了，那我们访问不存在的内存对象会发生什么错误？对，野指针错误！大家不要嫌我啰嗦，这个过程大家一定要明白，也一定要会分析对象的引用计数。要不然到最后会很麻烦的，经常出现一大堆莫名其妙的错误。

既然知道问题了，那问题就好解决了

解决方法：

我们可以使retain对象，使计数器+1，至于在哪里retain，我们可以遵循一个原则：谁调用对象谁retain，Student的stu要使用book对象，那就让Student自己在setBook中retain最好

-(void)setBook:(Book *)_book{
        book=[_book retain];   
}

好，解决了野指针的问题，但是对于内存泄露还没有解决，那么我们在哪里release呢？test1中？肯定不行，因为test1()中没有retain，new或者alloc等创建对象的语法，release的话违背了我们“谁创建谁释放“的原则。既然stu对象想使用book对象，你就应该在retain完成后释放它，而不应该把它交给test1()去release。至于在Student对象的什么时候释放最好呢？当然是在stu对象结束退出之后，stu对象都不存在了，book对象就更没有存在的必要了。所以在Student对象的dealloc中释放掉book对象最合适。

#pragma mark 回收对象  
- (void)dealloc{  
      
    //释放book对象  
    [book release];  
      
    NSLog(@"student %i 被销毁了", age);  
      
    [super dealloc];  
}  

这个问题已经完美解决了，那我们来看下一个问题。假如我在test()方法中新创建一个对象book2，调用initWithPrice改变price的值

void test(Student *stu){  
    Book *book = [[Book alloc] initWithPrice:3.5];  
    stu.book = book;  
      
    [book release];  
      
    Book *book2 = [[Book alloc] initWithPrice:4.5];  
    stu.book = book2;  
    [book2 release];  
      
} 

其他都保持不动，为了方便大家阅读，我们把main方法考过来

int main(int argc, const char * argv[])  
{  
  
    @autoreleasepool {  
          
        Student *stu = [[Student alloc] initWithAge:10];  
          
        test(stu);  
          
        test1(stu);  
          
        [stu release];  
          
    }  
    return 0;  
}  

这样大家看一下，有没有内存泄露，这个大家要根据引用计数进行分析，引用计数为0时进行释放。那我们来运行一下

2013-10-21 17:43:01.519 对象之间的内存管理[2743:303]当前读的书的价格是：4.500000

2013-10-21 17:43:01.521 对象之间的内存管理[2743:303] book 4.500000被销毁了

2013-10-21 17:43:01.523 对象之间的内存管理[2743:303] student 10被销毁了

book 3.500000这本书没有被销毁，为什么没有被销毁？

大家先不要看下边的，先自己想一想

大家学软件编程一定要有自己独立思考和分析问题的能力，这样大家才能走的更高更远，当然这只是我个人的一点浅见，毕竟我也是一个想要飞的菜鸟。

那废话就不多说了，我直接告诉大家

在stu.book=book2时，调用了setBook方法又进行了一次retain，这时候引用计数器为2，但是在最后释放调用dealloc方法时，仅仅进行了一次release，所以最后引用计数器还是为1，造成了内存泄露。

所以我们可以改进一下：

- (void)setBook:(Book *)_book{  
    //先释放旧的成员变量  
    [book release];  
      
    //再retain新传进来的对象  
    book = [_book retain];  
}

我们可以先把旧的成员释放了，在retain新传进来的对象，这样就没有问题了

但是仔细想想还是有一点小瑕疵，假如，我在test()方法中不小心多写了一句stu.book=book;

void test(Student *stu){  
    Book *book = [[Book alloc] initWithPrice:3.3];  
    stu.book = book;  
      
    [book release];  
    stu.book = book;

}

此时，stu.book 又再一次调用setter函数，在setter函数中release了book，问题是此时的book对象和_book对象时一样的，book对象被释放了（即_book指向的内存也不存在了），_book对象又再一次retian操作，就会造成野指针。

所以，要判断一下传进来的对象是否为当前对象，如果是当前对象的话就没有必要再一次release，修改如下：

- (void)setBook:(Book *)_book{  
    if(_book != book){  
        //先释放旧的成员变量  
        [book release];  
        //再retain新传进来的对象  
        book = [_book retain];  
    }  
}  

完美的内存管理，这样就是一段很完美的代码了

视频相关链接

http://pan.baidu.com/s/1jGLbz06