ios内存管理2-对象之间的内存管理

最新推荐文章于 2023-07-15 16:20:18 发布

和猫妹学Python

最新推荐文章于 2023-07-15 16:20:18 发布

阅读量311

点赞数

分类专栏： oc

oc 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

转自于http://blog.csdn.net/chaoyuan899

同之前一样，新建一个基于命令行的工程，在新建一个Student类和一个Book类

编写如下代码：

Student.h

[cpp] view plain copy print ?

//
// Student.h
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#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

[cpp] view plain copy print ?

//
// Student.m
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#import "Student.h"
@implementation Student
@synthesize age, book;//在Xcode4.5及以后的版本中，这一句可以省略，编译器会自动实现getter和setter方法
#pragma mark - 生命周期方法
#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

[cpp] view plain copy print ?

//
// Book.h
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface Book : NSObject
{
float price;
}
@property float price;
- (id)initWithPrice:(float)_price;
@end

Book.m

[cpp] view plain copy print ?

//
// Book.m
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#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

[cpp] view plain copy print ?

//
// main.m
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#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.3];
stu.book = book;
[book release];
[stu release];
}
return 0;
}

运行结果如下：

2013-08-26 18:17:58.316内存管理2-对象之间的内存管理[2049:303] book 3.300000被销毁了

2013-08-26 18:17:58.318内存管理2-对象之间的内存管理[2049:303] student 10被销毁了

这样看来好像一切都没问题，不会造成任何的内存泄露，，，在比较小的程序中没什么问题，但是在实际开发中，在稍大的项目中，这样写就有很大的隐患。在真实的开发环境中，我们往往要写很多的方法函数，为了测试，现在我们增加一个test( )函数，在test函数中实现对Book类的调用，如下：

[cpp] view plain copy print ?

//
// main.m
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#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;
}

点击运行，结果如下：

2013-08-26 18:48:40.125内存管理2-对象之间的内存管理[2337:303] student 10被销毁了

很明显，，出现了内存泄露，book对象没有被释放。此时，book的引用计数器为1。（OC通过引用计数器来管理内存，当引用计数器为0时销毁对象进行内存回收）

那么应该怎样解决呢？有人说直接在

[cpp] view plain copy print ?

stu.book = book;

后面直接加一句

[cpp] view plain copy print ?

[book release];

可以，问题解决了，，但是如果我想增加一下需求，假如现在我又有一个方法test1( )，用它来操作Student，，先我们再给Student类增加一个方法叫readBook( ),用于打印出学生当前读的书的价格。然后再在main函数中调用 test1() 这个函数

Student.h增加如下声明：

[cpp] view plain copy print ?

- (void)readBook;

Student.m进行实现：

[cpp] view plain copy print ?

#pragma mark - 公共方法
#pragma mark 读书
- (void)readBook{
NSLog(@"当前读的书的价格是：%f",book.price);
}

mian.m函数修改如下：

[cpp] view plain copy print ?

//
// main.m
// 内存管理2-对象之间的内存管理
//
// Created by Rio.King on 13-8-26.
// Copyright (c) 2013年 Rio.King. All rights reserved.
//
#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;
}

请注意test1()函数里的

[cpp] view plain copy print ?

[stu readBook];

这一句，，这一句访问的是下面这个函数

[cpp] view plain copy print ?

- (void)readBook{
NSLog(@"当前读的书的价格是：%f",book.price);
}

而这里的book对象已经在test()函数中已经被释放掉了，不存在该内存区域了，再去访问的话就会造成野指针了。那能不能把test( )函数中的 [ book release ]放到test1( ) 函数中，，，这样的思路是正确的，但是有很多不好的地方，1、不符合我们之前说过的内存管理的原则（谁创建，谁释放）；2、还要把 stu 对象传递到test1( )，当代码一多的时候就会很麻烦且使代码显得冗余，所以不用这种方法。

所以不要用这种方法

解决办法：可以用 retain 对象，使引用计数器加1。至于在什么地方retain呢？有一个原则是谁想使用该对象，谁就去retain。这里是Student 的stu对象要使用book对象，所以要Student自己去retain，在stu的setBook函数retain是最好的。（原则：谁想使用book对象，谁就去retain）

直接在setBook（）方法中retain，，注意，不要在test（）方法中retain，，why??还是上面的原则。

[cpp] view plain copy print ?

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

以上虽然解决了野指针的问题，，但是却没有release，，我们不在test1()中进行release，，是因为test1()函数中并没有明显的alloc或new一个对象，突然间出现一个release显得很唐突，2二来不符合内存管理的法则（谁创建，谁释放），既然stu对象想使用book对象，你就应该在retain完成后释放它，而不应该把它交给test1()去release。至于在Student对象的什么时候释放最好呢？当然是在stu对象结束退出之后，stu对象都不存在了，book对象就更没有存在的必要了。所以在Student对象的dealloc中释放掉book对象最合适。

代码如下：

[cpp] view plain copy print ?