OC中的内存问题

常见的内存问题有以下几种：

1.野指针异常：访问没有所有权的内存，如果想要安全的访问，必须确保空间还在

2.内存泄露：空间使用完之后没有及时释放

3.过度释放：对同一块存储空间释放多次，立刻crash

4.内存溢出：所有存储空间被占用

管理内存的三种方式：

1.垃圾回收机制：程序员只需要开辟存储空间，系统会自动回收内存，Java采用该机制

2.MRC:手动引用计数机制，由开发人员开辟空间，手动添加影响引用计数增加或减少的方法，能够灵活的控制空间何时释放。

3.ARC:自动引用计数机制，是iOS5.0退出的，基于MRC，不需要程序员手动添加管理内存的代码，编译器会在合适的位置自动添加管理内存的代码。

MRC和ARC都是采用引用计数来管理对象内存的

// 引用计数机制：

iOS采用引用计数来管理内存，当你想拥有这个对象的时候，需要使该对象的引用计数+1，使用完这个对象的时候，使该对象的引用计数-1，当对象的引用计数为0的时候，表示没有任何对象对该对象持有，那么这时候系统会自动调用dealloc方法来回收该对象的存储空间。

// 影响引用计数的方法

1.使用引用计数+1的方法：alloc，retain，copy

2.使用引用计数-1的方法：release，autorelease

下面我们创建一个Person类，还有一个结婚协议（顺道说下协议的问题）

Person.h

 #import <Foundation/Foundation.h>
 #import "MarryProtocol.h"   // 引入协议所在的.h文件

 // 让Person类遵守MarryProtocol协议
 @interface Person : NSObject <MarryProtocol, NSCopying>

 @property (nonatomic, retain) NSString *name;
 @property (nonatomic, retain) NSString *gender;

 @end

Person.m

 #import "Person.h"

 @implementation Person

 // 重写dealloc方法
 // dealloc相当于临终遗言
 - (void)dealloc
 {

     NSLog(@"该对象%@被销毁", self);
     [super dealloc];   // 让父类回收存储空间，这句话通常写在最后
 }

 - (NSString *)description
 {
     return [NSString stringWithFormat:@"name = %@, gender = %@", _name, _gender];
 }

 // 实现协议中的copyWithZone：方法
 //- (id)copyWithZone:(NSZone *)zone {
 //
 //    // 伪拷贝：拷贝地址，相当于retain，引用计数+1
 //    return [self retain];
 //
 //}

 //- (id)copyWithZone:(NSZone *)zone {
 //
 //    // 浅拷贝:对象开辟新的空间，但两个对象的实例变量指向同一块存储空间(zone是系统申请的内存池)
 //    Person *person = [[Person allocWithZone:zone] init];
 //    person.name = self.name;
 //    person.gender = self.gender;
 //
 //    return person;
 //}

 - (id)copyWithZone:(NSZone *)zone {

     // 深拷贝：对象开辟新的存储空间，并且对象的实例变量指向不同的存储空间(zone是系统申请的内存池)
     Person *person = [[Person allocWithZone:zone] init];
     person.name = [self.name mutableCopy];
     person.gender = [self.gender mutableCopy];
     return person;
 }

 // 实现协议中的方法

 // 不能家暴
 - (void)noViolence {
     NSLog(@"不能家暴");
 }

 // 不能出轨
 - (void)noDerail {
     NSLog(@"不能出轨");
 }

 // 不能抽大烟
 - (void)noSmoking {
     NSLog(@"不能抽烟");
 }

 // 不能藏私房钱
 - (void)noSelfMoney {
     NSLog(@"不能藏私房钱");
 }

 // 做家务(可实现也可以不实现)
 - (void)doHousework {
     NSLog(@"做家务");
 }

 @end

MarryProtocol.h（结婚协议）

 #import <Foundation/Foundation.h>

 // 定义一个协议:@protocol...@end
 @protocol MarryProtocol <NSObject>

 // 定义方法

 @required // 指定协议中的方法必须遵守
 // 不能家暴
 - (void)noViolence;

 // 不能出轨
 - (void)noDerail;

 // 不能抽大烟
 - (void)noSmoking;

 // 不能藏私房钱
 - (void)noSelfMoney;

 @optional  // 方法可以实现也可以不实现
 // 做家务
 - (void)doHousework;

 @end

main.m

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

 int main(int argc, const char * argv[]) {
     @autoreleasepool {

         // alloc的作用：开辟空间，让对象的引用计数由0变成1
         Person *person = [[Person alloc] init];

         // 查看对象的引用计数retainCount
         // retainCount是MRC才有的机制，所以如果使用的话，需要将ARC转化为MRC
         NSUInteger count = person.retainCount;   //
         NSLog(@"%lu", count);

         // retain 使对象的引用计数+1
         [person retain];   //
         NSLog(@"%lu", person.retainCount);

         // release 使对象的引用计数-1
         [person release];   //
         NSLog(@"%lu", person.retainCount);

         [person release];   // 0   当对象的引用计数为0，系统自动调用dealloc方法
         person = nil;   // 对象置为nil，防止野指针异常

         // 如果对象已经被回收，当前代码无效
         // 开启僵尸模式检查野指针异常
         // 如果一个对象被销毁，这个对象就称为僵尸对象
         NSLog(@"%lu", person.retainCount);
         // 这句话默认情况下不报错，如果要报错，需要开启僵尸模式

         // autorelease
         Person *person1 = [[Person alloc] init];   //
         Person *person2 = [person1 retain];   //
         NSLog(@"person1 = %lu, person2 = %lu", person1.retainCount, person2.retainCount);

         Person *person3 = [person1 retain];   //
         NSLog(@"person1 = %lu, person2 = %lu, person3 = %lu", person1.retainCount, person2.retainCount, person3.retainCount);

         [person3 release];  // 2 立刻-1
         NSLog(@"person1 = %lu, person2 = %lu, person3 = %lu", person1.retainCount, person2.retainCount, person3.retainCount);

         [person2 autorelease];  // 在未来的某个时刻-1
         NSLog(@"person1 = %lu, person2 = %lu, person3 = %lu", person1.retainCount, person2.retainCount, person3.retainCount);

         // 自动释放池
         // 定义一个自动释放池
         // 第一种形式
         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
         NSLog(@"%lu", pool.retainCount);

         Person *p1 = [[Person alloc] init];  //
         NSLog(@"%lu", p1.retainCount);

         [p1 retain];  //

         [p1 autorelease];   //
         NSLog(@"%lu", p1.retainCount);

         [pool release];   // 销毁自动释放池
         NSLog(@"%lu", p1.retainCount);   // 1

         // 对象使用autorelease是在未来的某一个时刻让对象的引用计数-1，这个某一时刻指的是喷到自动释放池之后才会释放

         // 第二种形式 (在iOS5.0之后推荐使用的)
         @autoreleasepool {
             Person *p2 = [[Person alloc] init];   //
             p2.name = @"p2";
             [p2 autorelease];   //

             Person *p3 = [[Person alloc] init];
             p3.name = @"p3";
             //[p3 autorelease];
         }

         // 自动释放池的作用：自动释放池会在销毁之前检查内部有没有autorelease操作，如果有autorelease操作，让该对象的引用计数做一次-1操作

         // 内存管理原则：
         // 凡是使用alloc，retain让对象的引用计数+1，相应的就该使用release或者autorelease让对象的引用计数-1，也就是说增加的次数要和减少的次数相等，才能保证对象的引用计数最终为0，对象才会被销毁。

         // 增加次数和减少次数不一致，会出现内存问题

         // 1.内存泄露：增加的次数大于减少的次数
         // 情况1
         Person *per1 = [[Person alloc] init];

         // 情况2
         Person *per2 = [[Person alloc] init];
         [per2 retain];
         [per2 release];

         // 情况3
         Person *per3 = [[Person alloc] init];
         per3 = nil;
         [per3 release];

         // 2.过度释放：增加的次数小于减少的次数
         Person *q = [[Person alloc] init];
         [q retain];
         [q release];
         [q release];
         [q release];  // 过度释放

         // 3.野指针异常：增加的次数等于减少的次数，还将继续访问
         Person *x = [[Person alloc] init];
         [x retain];
         [x release];
         [x release];
         //x = nil;   // 没有这一句，就会野指针异常
         NSLog(@"%lu", x.retainCount);

         // 并不是所有的对象都能进行copy操作，只有遵循NSCopying协议并实现copyWithZone：方法的对象才能进行copy
         Person *pe = [[Person alloc] init];
         pe.name = @"hhh";
         [pe retain];
         NSLog(@"%lu", pe.retainCount);
         Person *pe1 = [pe copy];
         NSLog(@"%lu, %lu", pe.retainCount, pe1.retainCount);
         NSLog(@"%p, %p", pe.name, pe1.name);

         // copy和mutableCopy
         // copy出来的指针副本是不可变的
         NSString *str1 = @"詹姆斯";
         NSString *str2 = [str1 copy];
         NSLog(@"str1 = %p, str2 = %p", str1, str2);

         NSMutableString *mStr1 = [str1 copy];
         NSLog(@"mStr1 = %p", mStr1);

 //        [mStr1 appendString:@"威武"];
 //        NSLog(@"%@", mStr1);

         // mutableCopy拷贝出来的内容是可变的
         NSString *str3 = [str1 mutableCopy];
         NSLog(@"str3 = %p, str1 = %p", str3, str1);

         NSMutableString *mStr2 = [str1 mutableCopy];
         [mStr2 appendString:@"威武"];
         NSLog(@"%@", mStr2);

 //        NSArray *array = @[@"1", @"2", @"3"];
 //        NSMutableArray *mArray = [array mutableCopy];

         // 深拷贝和浅拷贝
         // 如果是深拷贝,那么成员对象的地址和之前的地址不同，如果是浅拷贝，成员变量的地址和之前的相同

     }
     return ;
 }