Objective-C—引用计数器、多个对象之间的内存管理、set方法的内存管理、@property参数、循环引用

---引用计数器

#import<Foundation/Foundation.h>
int main()
{
    //创建一个对象p
    Person *p = [[Person alloc] init];
    //调用对象P的retainCount返回此时引用计数器的数值，此时为1
    NSUInteger c = [p retainCount]; // NSUInteger理解为long int    
    NSLog(@"%ld",c);   
    // 计数器的值+1，并且此方法返回对象本身，此时计数器数值为2
    [p retain];    
    //1
    [p release];
    //0
    [p release]; // 此时对象被回收，原来位置的对象被称为僵尸对象
    p = nil;//将指针清空,出现以下代码时，将不会在报错，因为指针已经为空   
    //其中的指针P将会成为野指针。
    //野指针：指向僵尸对象（不可用内存）的指针    
    //[p release];  此时在对僵尸对象做[p release]将会报错
    //[p release];  显示为EXC_BAD_ACCESS：访问了一块坏的内存（已经
    //[p release];  不可用的内存
    //[p release];
    
    //p.age = 10;此时会报错误，因为oc不存在空指针错误，给空指针发送消息，不报错，所以一         
      般在[p release]数值为0时，回收对象内存时就会清空指针    
}

重写dealloc方法：

@implementation Person
// 当一个Person对象被回收的时候，就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");
    
    // super的dealloc一定要调用，而且放在最后面
    [super dealloc];
}

@end

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

1.你想使用（占用）某个对象，就应该让对象的计数器+1（让对象做一次retain操作）
2.你不想再使用（占用）某个对象，就应该让对象的计数器-1（让对象做一次release）
3.谁retain，谁release
4.谁alloc，谁release

@implementation Person
- (void)setBook:(Book *)book
{
    _book = [book retain]; // 对计数器上网数值+1，并返回原对象
}

- (Book *)book
{
    return _book;
}

- (void)dealloc
{
    [_book release]; // 释放book对象内存
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end

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方法的内存管理

在多对象的编程里面，假如对象Person里面包含Car这个对象，并且假若有多辆车，当人想换车的时候，只是在dealloc方法里面的release方法就不能释放曾经使用过的Car的对象内存，这个时候就应该在写set方法的时候假如必要的release方法

void test2()
{
    Person *p1 = [[Person alloc] init];
    p1.age = 20;
    
    // c1 - 1
    Car *c1 = [[Car alloc] init];
    c1.speed = 100;
    // c1 - 2
    p1.car = c1;
    // c1 - 1
    [c1 release];
    
    Car *c2 = [[Car alloc] init];
    c2.speed = 200;
    // c1 - 0
    p1.car = c2; //人不使用Car1，而使用Car2就需要对setter方法改进
    
    [c2 release];
    
    [p1 release];
}

内存管理代码规范：
 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];
    }
 }
 
 3.dealloc方法的代码规范
 1> 一定要[super dealloc]，而且放到最后面
 2> 对self（当前）所拥有的其他对象做一次release
 - (void)dealloc
 {
    [_car release];
    [super dealloc];
 }

---@property参数

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;

正常情况下对weight这个成员变量进行
@property (nonatomic, assign, readwrite,setter = setWeight:,getter = weight) int weight；

---循环引用

在程序中，有可能会出现两个类互相包含的情况，这时候如果在 .h 头文件里面用的是#import互相包含对象，编译器会报错，这时候就应该是用 @class 类名；来进行说明。

以下代码两端都用的retain:
/*
@class Card;

@interface Person : NSObject

@property (nonatomic, retain) Card *card;

@end
*/

*/
@class Person;

@interface Card : NSObject

@property (nonatomic, retain) Person *person;

@end
*/

int main()
{
    // p - 1
    Person *p = [[Person alloc] init];
    // c - 1
    Card *c = [[Card alloc] init];
    
    // c - 2
    p.card = c;
    
    // p - 2
    c.person = p;
    
    // c - 1
    [c release];
    
    // p - 1  
    [p release];
    return 0;
}

1.@class的作用：仅仅告诉编译器，某个名称是一个类
  @class Person; // 仅仅告诉编译器，Person是一个类
  一般如果不是继承父类的时候就会使用@Class，节约性能，如果使用@import那么就会把里面对象  的所有东西都会拷贝一遍
 
2.开发中引用一个类的规范
 1> 在.h文件中用@class来声明类
 2> 在.m文件中用#import来包含类的所有东西
 
3.两端循环引用解决方案
 1> 一端用retain
 2> 一端用assign

/*
@class Card;

@interface Person : NSObject

@property (nonatomic, assign ) Card *card;

@end
*/

*/
@class Person;

@interface Card : NSObject

@property (nonatomic, retain) Person *person;

@end
*/

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;
}