oc MRC内存管理机制alloc/retain/copy/release/autorelease

////////////////////////////////////////////////////////////////////////////////

main.m

//////////////////////////////////////////////////////////////////////////////

#import <Foundation/Foundation.h>

#import "Person.h"

#import "Person1.h"

#import "Student.h"

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

Person *person=[[Person alloc]init];

[person retain];

@autoreleasepool {

Person *person=[[Person alloc]initWithName:@"bill" Age:23];

//在堆区开辟一块空间，存储创建好的person对象。

//对象的存储空间地址在person中。

//person指向创建的对象。

//通常，我们将指向某个对象的指针，代指对象。

Person *person2=person;

//person3也是一个指针，没有指向任何对象。

//nil 就是空。只能给指针赋值。

//在Oc中对nil的任何操作都是无效的。也就是空操作。

Person *person3=nil;

[person3 isEqualTo:person2];

#pragma mark ===== 内存管理机制 ========

//gar ==》ARC改为NO

//引用计数。--只开辟一个空间，所有的操作都是对这一个空间的操作。

//多个指针指向同一个对象。

//为了避免出现野指针，对象使用时，需要引用计数+1，释放对象时，引用计数-1。

#pragma mark ======= alloc ===========

//引用计数+1。

//0==》1的过程。

Person *palloc=[[Person alloc]init];

NSLog(@"palloc-alloc之后的:%lu",[palloc retainCount]);

#pragma mark ======= retain =============

//引用计数+1。

[palloc retain];

NSLog(@"palloc-retain之后:%lu",[palloc retainCount]);

//另外一个指针指向palloc，不会影响引用计数。

//单纯的指向是不会影响引用计数的，引用计数要改变必须是对这块地址有所操作。

Person *palloc2=palloc;

NSLog(@"%lu",palloc2.retainCount);

[palloc2 retain];

NSLog(@"%lu",palloc2.retainCount);

#pragma mark ====== release ===============

//引用计数-1。

NSLog(@"palloc没有release之前:%lu",[palloc retainCount]);

[palloc release];

NSLog(@"palloc用了release之后:%lu",[palloc retainCount]);

[palloc release];

NSLog(@"---%lu",[palloc retainCount]);

[palloc release];

// NSLog(@"==%lu",[palloc retainCount]);

#pragma mark ====== autorelease ==============

//在未来的某一时刻引用计数-1。

Person *Pautorelease=[[Person alloc]init];

[Pautorelease retain];//2

[Pautorelease autorelease];//还是2，未来会-1.出了池子会-1.

NSLog(@"[[[%lu",[Pautorelease retainCount]);

[person retain];

[person autorelease];

NSLog(@"autorelease:池子里>>%lu",person.retainCount);

#pragma mark ======== copy ===============

//

Person *perCopy=[[Person alloc]init];

NSLog(@"copy前:%lu",perCopy.retainCount);

Person *per4=[perCopy copy];

NSLog(@"copy后:%lu",per4.retainCount);

#pragma mark ======= Person1.h/.m =============

//创建释放池

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

Person1 *per1=[[Person1 alloc]init];//1

per1.name=@"hjki";

per1.age=13;

[per1 retain];//2

[per1 retain];//3

[per1 release];//2

[per1 autorelease];//暂时为2,放到栈中，出了释放池，从栈顶开始释放掉。===>这块地址的引用计数为1

NSLog(@"池子内部autorelease:%lu",[per1 retainCount]);

// [per1 autorelease];//===》变为0

// [per1 release];//过度释放。

//内存泄露：定义完，没有释放。

// NSLog(@">>%lu",[per1 retainCount]);

//销毁释放池

[pool release];

//自动释放池有两种格式，MRC下支持两种写法。

//在ARC下只支持@autoreleasepool{}写法。

NSLog(@"池子外面autorelease:%lu",[per1 retainCount]);

NSLog(@"%lu",[per1 retainCount]);

Person1 *per2=[[Person1 alloc]init];

per2.name=@"nmk";

per2.age=19;

[per2 retain];//引用计数:2

[per2 retain];//3

//per3指向新拷贝的对象。

Person1 *per3=[per2 copy];

NSLog(@"%@,%ld",per3.name,per3.age);

NSLog(@"深拷贝per2=>:%lu,per3=>:%lu",per2.retainCount,per3.retainCount);

NSLog(@"深拷贝拷贝的内容:%@,%ld",per3.name,per3.age);

//深拷贝，是拷贝地址的内容，即创建新的对象。

//拷贝的是内容，所以实质上没有对地址进行操作，所以，引用计数不改变。

//浅拷贝，拷贝的是指针，即操作的是原来的对象，没有创建新的对象。

NSLog(@"深拷贝后地址=》per2:%p,per3:%p",per2,per3);

#pragma mark ===== Student.h/.m ====================

Student *stu1=[[Student alloc]init];

stu1.name=@"bejin";

stu1.gender=@"male";

stu1.number=29;

[stu1 retain];

//浅拷贝==>拷贝的竟然是地址，是对同一块地址的操作。

//浅拷贝的时候，相当于是对该地址进行了操作。所以引用计数+1.

Student *stu2=[stu1 copy];

NSLog(@"stu2:%@,%@,%ld",stu2.name,stu2.gender,stu2.number);

NSLog(@"浅拷贝后的地址stu1=>:%p=====stu2=>:%p",stu1,stu2);

NSLog(@"浅拷贝stu1=>%lu,stu2=>%lu",stu1.retainCount,stu2.retainCount);

#pragma mark ========== NSString 内存 ========================

//指向的是常量区

NSString *str1=@"中国";

NSLog(@"str1引用计数:%lu",str1.retainCount);

//指向的是堆区

NSString *str2=[[NSString alloc]initWithFormat:@"中国北京"];

NSLog(@"str2引用计数；%lu",str2.retainCount);

NSLog(@"str2地址:%p",str2);

//下面这句竟然是浅拷贝。浅拷贝是对引用计数有影响，会使计数+1.至于为什么会这样，估计就只能自己没事猜测猜测底层代码了。

//本来，alloc是要开辟一个新地址的，由于在检测过程中，发现拷贝的是一个字符串，所以，就不必开辟新的了，之后，str4和str2就公用一个地址，所以属于浅拷贝，并且浅拷贝属于对地址的直接的操作，所以，引用计数要+1。

NSString *str4=[[NSString alloc]initWithString:str2];

NSLog(@"str4引用计数:%lu str2引用计数:%lu",str4.retainCount,str2.retainCount);

NSLog(@"str4地址:%p str2地址:%p",str4,str2);

//

NSString *str3=[[NSString alloc]initWithString:str1];

NSLog(@"str3引用计数:%lu,%lu",str3.retainCount,str1.retainCount);

}

NSLog(@"\nautorelease:池子外>>%lu",person.retainCount);

return 0;

}

//////////////////////////////////////////////////////////////////////////

Student.h

/////////////////////////////////////////////////////////////////////////

#import <Foundation/Foundation.h>

@interface Student : NSObject<NSCopying>

@property(nonatomic,retain) NSString *name;

@property(nonatomic,retain) NSString *gender;

@property(nonatomic,assign) NSInteger number;

@end

////////////////////////////////////////////////////////////////////////

Student.m

/////////////////////////////////////////////////////////////////////////

#import "Student.h"

@implementation Student

//浅拷贝的重写方法。

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

return [self retain];

}

@end

////////////////////////////////////////////////////////////////////////

Person1.h

/////////////////////////////////////////////////////////////////////////

#import <Foundation/Foundation.h>

@interface Person1 : NSObject<NSCopying>

@property(nonatomic,retain) NSString *name;

@property(nonatomic,assign) NSInteger age;

@end

///////////////////////////////////////////////////////////////////////////

Person1.m

///////////////////////////////////////////////////////////////////////////

#import "Person1.h"

@implementation Person1

//深拷贝的重写。

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

//原始的。如果需要兼容更低的版本，可以使用这句话。

// Person1 *p1=[[Person1 allocWithZone:zone]init];

//这是现在的。

Person1 *p1=[[Person1 alloc]init];

p1.name=self.name;

p1.age=self.age;

return p1;

}

//当对象的引用计数为0时，对象自动调用。

- (void)dealloc

{

NSLog(@"引用计数为零，对象自动调用。销毁对象%@，释放内存空间.",self);

[super dealloc];

}

@end

/////////////////////////////////////////////////////////////////////////////////

Person.h

/////////////////////////////////////////////////////////////////////////////////

#import <Foundation/Foundation.h>

@interface Person : NSObject<NSCopying>

@property NSString *name;

@property NSInteger age;

-(id)initWithName:(NSString*)name

Age:(NSInteger)age;

+(id)personName:(NSString*)name

Age:(NSInteger)age;

-(NSString *)description;

-(void)dealloc;

@end

////////////////////////////////////////////////////////////////////////////////

Person.m

///////////////////////////////////////////////////////////////////////////////////

#import "Person.h"

@implementation Person

//浅拷贝的重写。

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

return [self retain];

}

-(id)initWithName:(NSString*)name

Age:(NSInteger)age{

self=[super init];

if (self) {

_name=name;

_age=age;

}

return self;

}

+(id)personName:(NSString*)name

Age:(NSInteger)age{

Person *person=[[Person alloc]initWithName:name Age:age];

return person;

}

-(NSString *)description{

return [NSString stringWithFormat:@"%@,%ld",_name,_age];

}

-(void)dealloc{

[super dealloc];

NSLog(@"计数为0");

}

@end