day9: 内存管理初级：内存管理的方式、引用计数机制，影响计数的各个方法、dealloc方法、内存管理的基本原则

内存管理的黄金法则：
    黄金法则：每次调用alloc一次，都需要调用release一次，他们两是成对出现的。
 
 内存管理的对象：
    所有NSObject下的所有OC对象，都需要做内存管理，基本类型的
 
 内存管理初级
    内存常见问题体现在两个方面：内存溢出 和 野指针异常（大部分问题都是野指针异常问题）
    内存溢出：没有被释放掉的内存
    野指针异常：对象内存空间已经被系统回收，仍然使用指针操作这块内存，野指针异常是程序crash的主要原因，代码量越大的程序，越难找出出现野指针的位置
 
 了解内存管理，能帮我们提升程序性能，大大减少调试bug时间
 
 内存管理的方式：
    两种内存管理方式：ARC 和 MRC
    Manual Reference Count 人工引用计数（xcode 5 之后就用自动引用计数来管理了，不建议使用MRC,若使用MRC还的手工把ARC调为NO）
    Auto Reference Count 自动引用计数（ARC是基于MRC的）
    现在xcode可以
 
 引用计数机制
    C语言中，使用malloc和free，进行堆内存的创建和释放，堆内存只有正在使用和销毁两种状态
    实际开发中，可能会遇到，两个或两个以上的指针使用同一块内存。C语言无法记录内存使用者的个数
    OC采用引用计数机制管理内存，当一个新的引用指向对象时，引用计数器就递增，当去掉一个引用时，引用计数就递减，当引用计数为零时，该对象就将释放占有的资源
    影响引用计数的方法：
    +alloc   +1
    -retain  +1
    -copy    +1
    -release      -1
    -autorelease  -1
 
    dealloc方法
    -dealloc是继承自父类的方法，当对象引用计数为0的时候，由对象自动调用
 
 内存管理的基本原则
 
 自动释放池：autoreleasepool的使用
 通过autoreleasepool控制autorelease对象的释放
 自动释放池中是以栈的形式存在的，在池子释放的时候，会对池子里面所有的对象发送一条release消息，最后进池子的会最先收到release消息
 作用：1、把对象放入到自动释放池当中 (如果不在自动释放池中发送release和autorelease是不可以的)
      2、对象发送autorelease消息时，这个对象的引用计数不会立即-1，在出池子的时候才会-1；
      3、一个对象只能调用一次autorelease，不能多次调用
      4、autorelease的一个重要作用是在便利构造器当中使用
      5、向一个对象发送autorelease消息，这个对象何时-1取决于autoreleasepool

Person.h

#import <Foundation/Foundation.h>

//想要这个类的实例可以实现copy方法，就要遵守<NSCopying>协议
@interface Person : NSObject<NSCopying>

@property(nonatomic,assign)NSString * name;
@property(nonatomic,assign)NSInteger age;

-(instancetype)initWithName:(NSString *)name andAge:(NSInteger)age;
+(instancetype)initWithName:(NSString *)name andAge:(NSInteger)age;

-(void)setName:(NSString *)name;
-(void)setAge:(NSInteger)age;

@end

Person.m

#import "Person.h"

@implementation Person
@synthesize name = _name,age = _age;



//重写父类的方法
//当对象的引用计数从0到1的过程时，由系统来自动调用
-(void)dealloc{
    NSLog(@"%@ 对象已销毁",self);
    //父类的销毁实现方法是必须得调用的
    [super dealloc];
}

//初始化方法
-(instancetype)initWithName:(NSString *)name andAge:(NSInteger)age{
    if (self = [super init]) {
        _name = name;
        _age = age;
    }
    return self;
}

//便利构造器
+(instancetype)initWithName:(NSString *)name andAge:(NSInteger)age{
    Person *  p = [[Person alloc]initWithName:name andAge:age];
    //autorelease的一个重要作用是在便利构造器当中使用
    return  [p autorelease];
}

//NSCopying协议当中，必须实现的方法
-(id)copyWithZone:(NSZone *)zone{
    Person * p = [[Person allocWithZone:zone]init];
    p.name = self.name;
    p.age = self.age;
    return p;
}


//setter方法的内存设置
-(void)setName:(NSString *)name{
    if (_name != name) {
        [_name release];
        _name = [name retain];
    }
}

//基本数据类型  不用做内存管理
-(void)setAge:(NSInteger)age{
    _age = age;
}

@end

main.m

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


int main(int argc, const char * argv[]) {
    //相当于：NSAutoreleasePool * pool = [[NSAutoreleasePool alloc]init];
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        
        //+alloc
        Person * p = [[Person alloc]init];   //p.retainCount = 1
        
        //得到p的引用计数(代表有多少指针指向它)
        NSUInteger pCount = p.retainCount;
        NSLog(@"p.retainCount = %lu",pCount);
        
        //retain p的引用在原来的基础上+1
        [p retain];                         //p.retainCount = 2
        [p retain];                         //p.retainCount = 3
        //release 让对象的引用计数-1
        [p release];                        //p.retainCount = 2
        [p release];                        //p.retainCount = 1
        [p release];                        //p.retainCount = 0
        
        //message sent to deallocated instance 野指针错误，向一个已经释放掉的对象发送了一条消息
        //避免野指针错误的解决方案：[nil release];
        //向一个nil发送都不会引起crash，因此当p所指向的堆内存的引用计数变为0时，p=nil；就不会引起程序的crash了
        p = nil;    //保证p所指向的空间引用计数为0 的时候，在使用的时候运行不崩溃。
        NSLog(@"p.retainCount = %lu",p.retainCount);
        
        //copy
        Person * p2 = [p copy];
        NSLog(@"p2.retainCount = %lu",p2.retainCount);
        
        //打印这两个地址，我们现在是拷贝出来的一个新的对象
        NSLog(@"p=%p,p2=%p",p,p2);
        
        //因为它遵守了NSCopying协议，所以可以调用copy这个方法
        NSString * str = @"zero";
        NSString * str2 = [str copy];
        //因为在常量区所以引用计数为-1；
        NSLog(@"str = %ld,str2 = %ld",str.retainCount,str2.retainCount);
        
        //autorelease 它的引用计数不会立即-1
        Person * p3 = [[Person alloc]init];
        [p3 autorelease];
        NSLog(@"p3.retainCount = %lu",p3.retainCount);
        
        
        @autoreleasepool {
            //接收autorelease消息的对象会被放入离它最近的自动释放池
            Person * p7 = [[[Person alloc]init]autorelease];
            NSLog(@"p7 = %ld",p7.retainCount);
            
            //用构造方法 初始化的对象
            Person * p8 = [Person initWithName:@"zero" andAge:18];
             NSLog(@"p8.retainCount = %ld",p8.retainCount);
//            [p8 release];
            p8 = nil;
            NSLog(@"p8.retainCount = %ld",p8.retainCount);
            
        }
        
        
        
        
        //----------copy--------------
        //浅拷贝：拷贝的是地址，也就是不会申请一块新的内存空间，源对象的内存空间的引用计数+1；
        //深拷贝：拷贝的是内容，也就是会申请一块新的内存空间，并把源内存空间中的内容拷贝进去，所以源内存空间的引用计数还是1，新内存空间的引用计数由0变为1；深拷贝拷贝出来的是一个可变的字符串对象。
        
//        把源对象的内容复制一份，在堆内存申请一块新内存空间，把复制的内容粘贴进去（拷贝的是内容）
        
        //浅拷贝 copy
        NSString * str5 = [[NSString alloc]initWithFormat:@"popo"];
        NSString * str6 = [str5 copy];
        NSLog(@"str5 = %@ str6 = %@",str5,str6);
        NSLog(@"str5 = %p str6 = %p",str5,str6);
        NSLog(@"str5.retainCount = %lu str6.retainCount = %lu",str5.retainCount,str6.retainCount);
        
        //深拷贝 mutableCopy
        NSMutableString * str7 = [str5 mutableCopy];
        NSLog(@"str5 = %p,str7 = %p",str5,str7);
        NSLog(@"str5.retainCount = %lu str7.retainCount = %lu",str5.retainCount,str7.retainCount);
        
        NSMutableString * mstr = [[NSMutableString alloc]initWithFormat:@"浩浩"];
        
        NSString * mstr2 = [mstr copy];
        NSLog(@"mStr = %p,  mStr2 = %p",mstr,mstr2 );
        
        NSMutableString * mStr3 = [mstr mutableCopy];
        [mStr3 appendFormat:@"你妹呢?"];
        
        NSLog(@"%@",mStr3);
        NSLog(@"mStr = %p,mStr3 = %p",mstr,mStr3);
        NSLog(@"%lu,%lu",mstr.retainCount,mStr3.retainCount);
        /*
         1、只有不可变字符串跟copy才是钱拷贝，其他三种都是深拷贝
         2、不管源字符串是否可变，只要用mutableCopy 拷贝出来的字符串都是可变的
         */
        
        Person * p5 = [Person initWithName:@"波波" andAge:18];
        Person * p6 = [p5 copy];
        p6.name = @"浩浩";
        p6.age = 20;
        NSLog(@"p5.retainCount = %lu,p6.retainCount = %lu",p5.retainCount,p6.retainCount);
        NSLog(@"p5 - %@,%ld",p5.name,p5.age);
        NSLog(@"p6 - %@,%ld",p6.name,p6.age);
        
        
        
        
    //这里的{相当于：[pool release];
    }
    
    //创建池子
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc]init];
    
    //创建三个对象放入到池子当中
    Person * p4 = [[Person alloc]init];
    Person * p5 = [[Person alloc]init];
    Person * p6 = [[Person alloc]init];
    
    //向一个对象发送autorelease消息，这个对象何时-1取决于autoreleasepool
    [p4 autorelease];
    [p5 autorelease];
    [p6 autorelease];
//    [p6 autorelease]; //引用计数为0的时候不能再次释放
    
    //打印这三个对象的地址
    NSLog(@"p4 = %@",p4);
    NSLog(@"p5 = %@",p5);
    NSLog(@"p6 = %@",p6);
    
    //释放池子
    [pool release];   
    
    return 0;
}