OC基础语法(五)---内存管理


一、基本原理
     什么是内存管理：
     移动设备的内存极其有限，每个app所能占用的内存是有限制的；
     当app所占用的内存较多时，系统会发出警告，这时得回收一些不需要再使用的内存空间。比如回收一些不需要的对象、变量等。
     管理范围：任何继承了NSObject的对象，对其他基本数据类型（int、char、float、double、struct、enum等）无效。
     
     栈：存放局部变量（调用完自动回收）；
     堆：动态产生的存储空间（需手动回收）。    

二、对象基本结构
每个对象都有自己的引用计数器，是一个整数。表示“对象被引用多少次”，即有多少人在使用这个对象。
    
每个对象OC对象内部专门有4个字节的存储空间来存储引用计数器。

引用计数器的作用：
1.创建新对象，该计数器默认是 1；
2.当一个对象的引用计数器为0，就被回收，或退出程序；
3.给对象发送一条retain消息，可以引用计数器 +1；
4.给对象发送一条release消息，可以使计数器-1；
5.可以给对象发送retainCount消息获得当前的引用计数器值。
    
[p retain]; 引用计数器 +1。
注：retain方法返回的是对象本身。

[p release]; 引用计数器 -1。

野指针：指向僵尸对象（不可利用的内存空间）的指针。
        当引用计数器变为0，p为野指针，这时候再往下使用p指针就会出
        错。
报错：下一行再使用 [p release]; 时
经典错误：EXC_BAD_ACCESS:访问了一块坏的内存（已经被回收，已经不可用的内存），即野指针错误。
此时对象已是僵尸对象，发送retain消息还是报错。

所以要将野指针清空： p = nil;
Java中有空指针错误，但OC中不存在。
给空指针发送消息，不报错。

注：方法的基本使用
1.retain：计数器+1，会返回对象本身；
2.release：计数器-1，没有返回值；
3.retainCount:获得当前的计数器值；
4.dealloc：当一个对象要被回收的时候，就会调用
               一定要在最后调用[super dealloc].要放在最后。
    
概念：
僵尸对象:所占用的内存已经被回收的对象，僵尸对象不能再使用。
野指针：指向僵尸对象的指针，给野指针发送消息会报错。
空指针：没有指向任何东西的指针（存储的东西是nil、NULL、0），给空指针发送消息不回报错。

多对象内存管理：
1.谁创建，谁release
如果你通过alloc、new、或者[mutable]copy来创建一个对象，那么你必须调用release或者autorelease，
换句话说，不是你创建的，就不用你去[auto]release.

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

总结：
1.有始有终，有加就有减；
2.曾经让对象的计数器+1，就必须在最后让对象-1.

三、set方法内存管理
内存管理代码规范：

OC对象类型，应当要严谨点：例如
- (void)setBook:(Book *)book
{
    //对当前正在使用的书（旧书）做一次release
    [_book release];

    //对新书做一次retain
    _book = [book retain];
}

最严谨的set方法：
- (void)setBook:(Book *)book
{//判断是不是新传来的对象
    If( book != _book)
    {
        [_book release];
         _book = [book retain];
     }
}

基本数据类型的set方法：
- (void)setAge:(int)age
{
   _age = age;
}

dealloc方法的代码规范：（不要直接调用dealloc）
1.一定要[super dealloc]，而且放在最后；
2.对当前对象（self）所拥有的其他对象做一次release。

例子： - (void)dealloc
       {
          [_book release];
          [super dealloc];                                           
        }

- @property内存管理:

.retain:生成的set方法里，release旧值，retain新值
 @property (retain)Book * book;

property参数：
1.控制set方法的内存管理：
（1）retain：release旧值，retain新值（适用于oc对象）；
（2）assign：直接赋值，不做任何内存管理（默认，用于非OC对象类型）；
（3）copy：release旧值，retain新值。

2.是否要生成set方法：
（1）readwrite：同时生成setter和getter的声明和实现；
 (2) readonly：只会生成getter的声明和实现。

3.多线程管理：
（1）nonatomic：性能高（一般用这个）；
 (2) atomic：性能低（默认）。

4.setter和getter的名称（不改变成员变量）：
@property (getter = abc,setter = setAbc:)int age;
[p setAbc:10]; 这种用法是对的；
[p setAge:10]; 这种用法是错的；

但是： p.age = 10; 
       p.abc = 10; 
都是对的。

另：一般返回BOOL类型方法名一般以 is 开头：
@property (getter = isRich)BOOL rich;
p.rich = YES;
BOOL b = p.rich;

四、循环引用
对于循环依赖关系来说：比方说A类引用B类，B类引用A类。
这种代码编译会报错，当使用@class在两个类相互声明，就不会出现编译报错。

@class:
1.@class的作用：声明仅仅告诉编译器，某个名称是一个类
      例如： @class Card;
2.开发中引用一个；类的规范：
（1）在.h文件中用@class来声明类；
（2）在.m文件中用#import来包含类的所有的东西。
3.两端循环引用的解决方案：
（1）一端用retain；
（2）一端用assign；

用@class的好处：
1.解决循环包含；
2.提高性能，头文件不会再随着包含的文件的改变而重新编译。

@class和#import的区别：

1.#import方式会包含被引用类的所有信息，包括被引用类的变量和方法；
      @class方式只是告诉编译器在A.H文件中 B *b 只是类的声明，具体这个类里面有什么信息，这里不需要知道，等文件真正实现的时候，才会真正去查看B类中的信息；

2.如果有上百个头文件都用#import了同一个文件，或者这些文件依次被#importm,那么一旦最开始的头文件稍有改动，后面引用这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对而言，用@class就不会出现这种问题了；

3.在.m文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引用引用类。
  
五、自动释放池
ios 5.0以后
autorelease方法：
1.会返回对象本身。
2.调用完autorelease，对象的计数器值不变，
3.会将对象放到一个自动释放池中，
4.当自动释放池被销毁时，会对池子里的所有对象做一次release操作。

@autoreleasepool
{//开始代表创建了释放池
    Person *p = [[[Person alloc] init] autorelease];
 
}//结束代表了销毁释放池

autorelease的好处：
1.不用再关心对象的销毁时间；
2.不用再关心什么时候调用release。

autorelease的使用注意：

1.占用内存较大的对象不要随意使用autorelease；

2.占用内存较小的对象使用autorelease，没有太大影响；

错误写法：

1.alloc 之后调用了autorelease，有调用了release；

2.连续多次调用了autorelease。、
    
    自动释放池：

1.在ios程序运行过程中，会创建无数个池子。这些池子都是以栈结构存在的（先进后出）；

2.当一个对象用autorelease方法时，会将这个对象放到栈顶的释放池。

ios 5.0以前的释放池（已淘汰）

NSAutoreleasePool *pool = [[NSAutorelease alloc] init];

Person *p = [[[Person alloc] init] autorelease];

[pool release];//[pool drain];

一般可以为类添加一个快速创建对象的类方法：

+ (id)person

{ 

  Return [[[self alloc] init] autorelease];

}

系统有会默认自动回收的：

例如：  NSString *str = @"123";

注：1.系统自带的方法里面没有包含alloc 、new、copy，说明返回的对象都是release 的

    2.开发中经常会提供一些方法，快速创建一个已经autorelease过的对象；   创建对象时不要直接用类名，一般用self。

   

六、练习
/*
set方法内存管理
*/

#implement <Foundation/Foundation.h>
//与Car和Dog类组合
#implement "Car.h"
#implement "Dog.h"

@interface Student : NSobject
{ 
  int _no; //学号
  NSString *_name; //姓名
  Car *_car; //car对象
  Dog *_dog; //dog对象

}

//方法的声明
- (void)setNo:(int)no;
- (int)no;

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

- (void)setCar:(Car *)car;
- (Car *)car;

- (void)setDog:(Dog *)dog;
- (Dog *)dog;

- (void)dealloc;

@end

@implementation Student

//方法的实现
- (void)setNo:(int)no
{
   _no = no;
}
- (int)no
{
   return _no;
}

- (void)setName:(NSString *)name
{
    //判断传进来的是不是新的对象
     if(name != _name)
   {
   //回收旧姓名
      [_name release]; 
     
  //retain新姓名
      _name = [name retain];
     
   }
}

- (NSString *)name
{
  return _name;

}

- (void)setCar:(Car *)car
{
     //判断传进来的是不是新的对象
    if(car != _car)
   {
    //回收旧车
      [_car release];

   //retain新车
    
      _car = [car retain];
     
   }
}

- (Car *)car
{
   return _car;
}

- (void)setDog:(Dog *)dog
{
      if(dog != _dog)
   {
      [_dog release];
    
      _dog = [dog retain];
     
   }

}
- (Dog *)dog
{
   return dog;
}

- (void)dealloc
{
//回收每个对象
    [_name release];
    [_car release];
    [_dog release];

    [super dealloc];

}
@end

int main()
{
//创建学生对象
    Student *stu = [[Student alloc] init];
  
//创建姓名对象
    NSString *name1 = @"rose";

//创建车子对象
Car *c1 = [[Car alloc] init];
c1.wheels = 4;
 
//将c1传递给stu
stu.car = c1;
    
   stu.name  = name1; 
   

   //alloc一次，release一次
   [c1 release];
   [stu release];

   return 0;
}