IOS学习笔记 第7篇 内存管理

一、内存管理的范围

    内存管理是OC开发中的重要部分，在一个应用程序运行时，如果超出系统所限定的内存，系统就会发出警告阻止程序的运行。因此，为了在开发过程中能够合理运用内存空间和

程序成功运行，必须要重视内存的开发。在程序运行中，数据会分别装在堆和栈中，在栈中的变量一般是局部变量，它们会在程序退出时释放内存，而对象放在堆中，系统不会自 

动将其释放，而在实际的开发过程中会有非常多的对象，这样会造成内存浪费。

 因此oc中内存管理的范围是：任何继承了NSObject的对象，也即是只要是对象都要进行释放内存，对基本数据类型如：int double struct 等不用进行麻烦的单独释放内存

二、计数器：

每个对象内部都保存了一个与之相关联的整数,称为引用计数器，可以给对象发送retainCount消息获得当前的引用计数器值。

原理：当一个对象的引用计数器值为0时,那么它将被销毁，其占用的内存被系统回收，系统也会自动向对象发送一条dealloc消息。一般会重写dealloc方法，在这里释放相关资

源。一定不要直接调用dealloc方法，而是要用super调用。

1.当使用alloc、new或者copy创建一个对象时,对象的引用计数器被设置为1

2.给对象发送一条retain消息,可以使引用计数器值+1

3.给对象发送一条release消息,可以使引用计数器值-1

方法的使用：

1>retain ：计数器+1，会返回对象本身

 2> release ：计数器-1，没有返回值

 3> retainCount ：获取当前的计数器

.在进行计数器操作时会出现一些特殊的概念：

 1> 僵尸对象 ：所占用内存已经被回收的对象，僵尸对象不能再使用

 2> 野指针 ：指向僵尸对象（不可用内存）的指针，给野指针发送消息会报错（EXC_BAD_ACCESS）

 3> 空指针 ：没有指向任何东西的指针（存储的东西是nil、NULL、0），给空指针发送消息不会报错

三、管理原则

1.谁创建，谁释放(“谁污染，谁治理”)。如果你通过alloc、new或(mutable)copy来创建一个对象（默认情况下就是1），那么你必须调用release或autorelease。换句话说，不是你创建的，就不用你去释放

2.一般来说,除了alloc、new或copy之外的方法创建的对象都被声明了autorelease

3.谁retain，谁release。只要你调用了retain，无论这个对象是如何生成的，你都要调用release

四、多对象内存管理

   有时一个对象会成为另外一个对象的属性，那么就会增加内存管理的复杂性，因此一定要注意计数器的值，否则会变成僵尸对象。

多对象内存管理的原则：

1.你想使用（占用）某个对象，就应该让对象的计数器+1（让对象做一次retain操作）

 2.你不想再使用（占用）某个对象，就应该让对象的计数器-1（让对象做一次release）

 3.谁retain，谁release

 4.谁alloc，谁release

例如：person的对象要占有某本书book的对象，那么在它的set方法内要retain一次这个对象以便使book的对象计数器加一；那么在person对象释放内存时，book对象的计数

器也要因此减一。这要在person的dealloc函数内对book对象retain一次。

下面是实现代码：

Person.h
  

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


@interface Person : NSObject
{
    Book *_book;
}


- (void)setBook:(Book *)book;
- (Book *)book;
@end

Person.m

@implementation Person
<span style="color:#ff6666;">- (void)setBook:(Book *)book
{
    _book = [book retain];
}</span>

- (Book *)book
{
    return _book;
}

<span style="color:#ff6666;">- (void)dealloc
{
    [_book release];
    NSLog(@"Person对象被回收");
    [super dealloc];
}</span>
@end

Book.h

#import <Foundation/Foundation.h>

@interface Book : NSObject
{
    int _price;
}

- (void)setPrice:(int)price;
- (int)price;
@end

Book.m

#import "Book.h"
@implementation Book
- (void)setPrice:(int)price
{
    _price = price;
}

- (int)price
{
    return _price;
}
- (void)dealloc
{
    NSLog(@"Book对象被回收");
    [super dealloc];
}
@end

main.m

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

int main()
{
    // b-1  代表它的计数器值
    Book *b = [[Book alloc] init];
    // p-1
    Person *p1 = [[Person alloc] init];
 
    //p1想占用b这本书
    // b-2
    [p1 setBook:b];
    
    // p-0
    // b-1
    [p1 release];
    p1 = nil;
    
    // b-0
    [b release];
    b = nil;
    return 0;
}

五、set方法的内存管理

   虽然在上面的例子中set方法可以做到将book对象的计数器加一，但是还是存在内存管理不当的风险，如果p想要换一本书那么在最后b的值就无法减为0，造成内存的浪费。

因此set方法对内存管理有很重要的作用。set方法里面，release旧值，retain新值。

内存管理代码规范：

 1.只要调用了alloc，必须有release（autorelease），对象不是通过alloc产生的，就不需要release

 2.set方法的代码规范
 1> 基本数据类型：直接复制
 - (void)setAge:(int)age
 { 
    _age = age;
 }
 
 2> OC对象类型
 - (void)setCar:(Car *)car
 {
    // 1.先判断是不是新传进来对象
    if ( car != _car )
    {
        // 2.对旧对象做一次release
        [_car release];
 
        // 3.对新对象做一次retain
        _car = [car retain];

        _car = car;
    }
 }
 
 3.dealloc方法的代码规范
 1> 一定要[super dealloc]，而且放到最后面

 2> 对self（当前）所拥有的其他对象做一次release
 - (void)dealloc
 {
    [_car release];
    [super dealloc];
 }

六、@property的参数

  之前学习的@property可以自动生成set方法get方法，现在再对它补充，可以增加一些参数为本次学习的内存管理增加方便。

如：@property (retain) Book *book;  其中 retain : 生成的set方法里面，release旧值，retain新值，因此不用像上节那样对每个对象都写差不多一样的 set方法。

1.set方法内存管理相关的参数

 * retain : release旧值，retain新值（适用于OC对象类型）

 * assign : 直接赋值（默认，适用于非OC对象类型）

 * copy   : release旧值，copy新值
 
 2.是否要生成set方法

 * readwrite : 同时生成setter和getter的声明、实现(默认)

 * readonly  : 只会生成getter的声明、实现
 
 3.多线程管理

 * nonatomic : 性能高 (一般就用这个)

 * atomic    : 性能低（默认）
 
 4.setter和getter方法的名称
 * setter : 决定了set方法的名称，一定要有个冒号 :      
 * getter : 决定了get方法的名称(一般用在BOOL类型)

如：

返回BOOL类型的方法名一般以is开头

@property (getter = isRich) BOOL rich;

@property (nonatomic, assign, readwrite) int weight;

@property (retain) NSString *name;

七、#import与@class的区别

通常引用一个类有两种办法：一种是通过#import方式引入；一种是通过@class引入

两种方式的区别:

1、#import方式会包含被引用类的所有信息，包括被引用类的变量和方法；

@class方式只是告诉编译器在A.h文件中 B *b 只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中信息

2、使用@class方式由于只需要知道被引用类（B类）的名称就可以了，而在实现类由于要用到被引用类中的实体变量和方法，所以在.m文件中需要使用#import来包含被引用

3、如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt，那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样 

的效率也是可想而知的，而相对来讲，使用@class方式就不会出现这种问题了类的头文件

4、对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类，如果两个文件都用#import，当程序运行时，编译会报错。当使用@class在两个类相互声明，就不会出现编译报错

  由上可知，@class是放在.h中的，只是在引用一个类，将这个被引用类作为一个类型，在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用户

#import方式引入被引用类

循环引用时注意：

1.@class的作用：仅仅告诉编译器，某个名称是一个类

 @class Person; // 仅仅告诉编译器，Person是一个类
 
 2. 开发中引用一个类的规范

 1> 在.h文件中用@class来声明类

 2> 在.m文件中用#import来包含类的所有东西
 
 3. 两端循环引用解决方案

 1> 一端用retain

 2> 一端用assign

如下：身份证是一个类，它占用某人的姓名、性别、年龄等信息，人也还一个类，他拥有身份证，相当于拥有一个对象

Card.h 

#import <Foundation/Foundation.h>


@class Person;

@interface Card : NSObject

@property (nonatomic, assign) Person *person;

@end

card.m

#import "Card.h"
#import "Person.h"

@implementation Card
- (void)dealloc
{
    NSLog(@"Car被销毁了");
    
    // [_person release];
    
    [super dealloc];
}
@end

person.h

#import <Foundation/Foundation.h>
#import "Card.h"
// @class仅仅是告诉编译器，Card是一个类
//@class Card;

@interface Person : NSObject

@property (nonatomic, retain) Card *card;

@end

person.m

#import "Person.h"
#import "Card.h"

@implementation Person
- (void)dealloc
{
    NSLog(@"Person被销毁了");
    [_card release];
    
    [super dealloc];
}
@end

 main.m

#import <Foundation/Foundation.h>
#import "Card.h"
#import "Person.h"
int main()
{
    // p - 1
    Person *p = [[Person alloc] init];
    // c - 1
    Card *c = [[Card alloc] init];
    
    // c - 2
    p.card = c;
    
    // p - 1
    c.person = p;
    
    // c - 1
    [c release];
    
    // p - 0  c - 0
    [p release];
    return 0;
}