内存管理 ARC + MRC

C语言内存管理

     char *p = malloc(100);   //在堆中开辟100个字节空间        strcpy(p,"hello");        NSLog(@"p = %s",p);        fun1(p);        fun2(p);//C内存管理的隐患：        //free(p);  //1.当fun1，fun2没用完malloc空间，执行了free，造成提前释放－－野指针        //2.担心传出去的空间，别人没用完，所有人都不去释放－－内存泄漏        free(p); //3.所有人都担心内存没释放，都执行free,造成重复释放 －－ 奔溃//OC中改善内存管理的机制－－引用计数        //引用计数： ARC 、MRC        //ARC:  自动引用计数－（默认）        //MRC:  手动引用计数## 标题 ##

ARC

int main(int argc, const char * argv[]) {    @autoreleasepool { //自动释放池        // insert code here...        //ARC执行过程:        //先执行@autoreleasepool括号内->dealloc->自动释放池括号外        Person *per = [[Person alloc] init];        NSLog(@"开辟空间");    }    NSLog(@"程序即将结束");    return 0;    }//析构方法：释放内存的方法；程序执行完毕，进入dealloc，说明已经释放该对象    - (void)dealloc    {        NSLog(@"Person dealloc");    }

MRC

int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        //MRC执行过程：        //release：只要对象的引用计数为0->立即dealloc(不会等到自动释放池结束)(推荐)        //autoRelease: 把引用计数－1抛给自动释放池，退出自动释放池立即执行dealloc        Person *per = [[Person alloc] init];        NSLog(@"开辟空间");        [per release];  //引用计数－1;  减到0时，才释放(调用dealloc)        //[per autorelease]; //有延迟的引用计数－1；        NSLog(@"空间－1");    }    NSLog(@"应用程序执行结束");    return 0;    }

MRC的Retain调用

int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        Person *xiaoM = [[Person alloc] init];        Person *xiaoQ = [xiaoM retain];  //引用计数＋1        Person *xiaoB = [xiaoQ retain];        NSLog(@"引用计数：%ld",[xiaoQ retainCount]);  //获取引用计数        [xiaoM release];   //引用计数－1，计数还剩1        NSLog(@"-1后，引用计数：%ld",[xiaoM retainCount]);  //获取引用计数        //[xiaoM release]; err 一定要使用内存管理黄金法则        [xiaoQ release];        [xiaoB release];        //释放的值，再打印无意义        //NSLog(@"retainCount = %ld",[xiaoB retainCount]);        //结论： 只要有alloc、retain、copy，就一定对应有release－内存管理黄金法则    }    return 0;}

字符串的内存管理

    NSString *str = [[NSString alloc] init];        //在字符串中不能用retainCount来获取引用计数        NSLog(@"retainCount = %ld",[str retainCount]);   //-1//1.NSString进行retain        NSString *str1 = [str retain];  //引用计数＋1        //字符串通过打印地址的方式，验证引用计数是否＋1        NSLog(@"str1:%p,str: %p",str1,str);        [str release];  //内部遵循内存管理的黄金法则        [str1 release];        NSMutableString *mutStr = [[NSMutableString alloc] init];//2.NSMuatableString进行retain        NSMutableString *mutStr1 = [mutStr retain]; //引用计数＋1        NSLog(@"mutStr:%p,mutStr1:%p",mutStr,mutStr1);        //结论：可变与不可变字符串进行retain，引用计数都＋1；//3.NSString进行copy        NSString *str2 = [str copy];   //引用计数＋1        NSLog(@"str: %p,str2: %p",str,str2);//4.NSMuatableString进行copy        NSString *str3 = [mutStr1 copy]; //引用计数不＋1        NSLog(@"str3 = %p,mutstr1=%p",str3,mutStr1);        //结论：不可变进行copy引用计数＋1，可变不＋1；//5.NSString进行mutableCopy        NSMutableString *mutStr2=[str3 mutableCopy]; //引用计数不＋1        NSLog(@"mutStr2=%p,str3 = %p",mutStr2,str3);//6.NSMutableString进行mutableCopy        NSMutableString *mutStr3 = [mutStr2 mutableCopy];//引用计数不＋1        NSLog(@"mutstr3=%p,mutStr2=%p",mutStr3,mutStr2);        //结论：可变与不可变字符串进行mutableCopy，引用计数都不＋1；//        //深拷贝：引用计数不＋1、字符串的mutableCopy始终为深拷贝        //浅拷贝：引用计数＋1、字符串的retain始终为浅拷贝

数组的内存管理

    Person *p1 = [[Person alloc] init];        Person *p2 = [[Person alloc] init];        Person *p3 = [[Person alloc] init];//1. 当元素对象放入数组，每一个对象的引用计数都＋1        NSMutableArray *mutArr = [[NSMutableArray alloc] initWithObjects:p1,p2,p3, nil];        NSLog(@"p1 count = %ld",p1.retainCount);  //2        NSLog(@"p2 count = %ld",p2.retainCount);  //2        NSLog(@"p3 count = %ld",p3.retainCount);  //2//2.在数组中添加一个对象，那么该对象的引用计数＋1        [mutArr addObject:p1];        NSLog(@"p1 count = %ld",p1.retainCount);  //3        NSLog(@"p2 count = %ld",p2.retainCount);  //2        NSLog(@"p3 count = %ld",p3.retainCount);  //2//3.数组中移除一个对象，那么该对象的引用计数－1        [mutArr removeObject:p3];        NSLog(@"p1 count = %ld",p1.retainCount);  //3        NSLog(@"p2 count = %ld",p2.retainCount);  //2        NSLog(@"p3 count = %ld",p3.retainCount);  //1//4.数组中溢出所有对象，那么每一个对象的引用计数都－1        [mutArr removeAllObjects];        //[mutArr release];        NSLog(@"p1 count = %ld",p1.retainCount);  //1        NSLog(@"p2 count = %ld",p2.retainCount);  //1        NSLog(@"p3 count = %ld",p3.retainCount);  //1        [p1 release];  //引用计数为0，调用dealloc        [p2 release];  //引用计数为0，调用dealloc        [p3 release];  //引用计数为0，调用dealloc

总结

     //1.回顾C内存管理的缺陷           //a. 提前释放  b. 重复释放  c. 没有释放        //2.引用计数的概念：           //a. ARC: 自动引用计数，退出自动释放池，系统自动会释放内存空间           //b. MRC: 手动引用计数；                //b1. 内存管理的黄金法则；                //b2. MRC默认的调用方法及标准写法                //调用方法：retain、retainCount、release、dealloc                //标准写法：记住复合类内存管理，字符串在类中的内存管理        //3. 字符串的内存管理                //深拷贝与浅拷贝的概念        //4. 数组的内存管理                //记住4个结论        //5.release与autorelease            //release: 引用计数－1（MRC推荐使用）            //autorelease: 有延时的引用计数－1

test

main：

int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        //创建对象        Engine *eng = [[Engine alloc] init];        Engine *eng2 = [[Engine alloc] init];        Car *car1 = [[Car alloc] initWithEngine:eng];        [car1 setEngine:eng2];        //释放对象        [eng2 release];        [eng release];        [car1 release];    }    return 0;    }car：    @implementation Car    //setter函数    -(void)setEngine:(Engine *)engine    {    if (_engine != engine) {        [_engine release];        _engine = [engine retain];    }    }    //getter函数    -(Engine *)engine    {    return _engine;    }    //Car对象初始化    -(id)initWithEngine:(Engine *)engine    {    self = [super init];    if (self) {     // _engine = [engine retain];        _engine = engine;        [engine retain];    }    return self;    }    //重写dealloc    - (void)dealloc    {        [_engine release];        NSLog(@"%@ was dealloc!",self);        [super dealloc];    }    @endEngine：    @implementation Engine    //重写dealloc    - (void)dealloc    {        NSLog(@"%@ was dealloc!",self);        [super dealloc];    }    @end