Objective-C 【在手动内存管理中如何写set方法】
———————————————————————————————————————————
set方法的内存管理
代码：
#import <Foundation/Foundation.h>
@interface Car : NSObject
-(void)run;
@property int speed;
@end
@implementation Car
-(void)run
{
NSLog(@"car run!");
}
- (void)dealloc
{
NSLog(@"car dealloc!");
[super dealloc];
}
@end
@interface Person : NSObject
{
Car *_car;
}
-(void)driver;
-(void)setCar:(Car *)car;
@end
@implementation Person
//test1中运用到的set方法
//-(void)setCar:(Car *)car
//{
// [_car release];//release一下原来的内存（注意：如果是第一次调用set方法，_car里面是nil，nil!=car，不过此时也是可以调用[_car release];的，只是不起作用罢了～）
// _car=[car retain];//给car的计数+1，然后赋给_car（如果是第一次set，那么为什么这里要retain呢，因为必须让计数等于2，因为在main函数里，我们在[p release]; 和 [car release];各释放了一次car，所以-2的前提是要+2）
//}
//改进后的set方法
-(void)setCar:(Car *)car
{
// 如果 _car 和 car 相等，那么就无需做任何操作了，因为之前已经做过一次setCar了。如果对原值操作release和retain。那么就会出现野指针（“僵尸对象复活”）。所以只有传入的值和先前的值不一样，才会做下列操作：①release原值 ②_car=car; ③retain新值
if (_car!=car) {
[_car release];
_car=[car retain];
}
}
-(void)driver
{
[_car run];
}
- (void)dealloc
{
[_car release];//上节知识点，我们之前在setCar里面retain car了一次，所以必须让car的计数减1.所以要再Person里有Car的实例变量，若要释放car的内存，在Person的dealloc里面可以做到这一点。但是我们就没法在Car的dealloc里面释放Person了。
NSLog(@"person dealloc!");
[super dealloc];
}
@end
//在test1中暂时保存～需要时拿出来运行检验
void test1()
{
// set方法的内存管理（1）———— 原对象无法被释放造成的内存泄漏问题
// 创建Person的实例对象p
Person *p=[[Person alloc]init];//p 1
// 创建Car的实例对象car1
Car *car1=[[Car alloc]init];//car1 1
car1.speed=120;
// 将car1赋给p（p拥有了第一辆车car1）
[p setCar:car1];//car1 2（在set方法中retain了一下）
[p driver];//想要driver，就要给p的Car赋值～（你要先给他一辆车）
[car1 release];//car1用完了我们可以将car1释放掉，car1 1
// 创建Car的实例对象car2
Car *car2=[[Car alloc]init];//car2 1
// 将car2赋给p（p拥有的第二辆车car2）
[p setCar:car2];//car2 2
// 我们知道，在setCar中是这么一句话：_car=[car retain]; 在此处，没运行这句话之时，因为之前曾经调用的setCar，所以_car中存的是car1的内存地址。而运行到此处_car又变为了新的car2，car2变成了2，而car1还是1没变。
[car2 release];//car2 1
[p release];//p 0 car2 0 car1 1
// 这样看来，因为_car中的内存地址在两次setCar中发生了改变，导致本来意图在[p release]的同时想要[car1 release]，却[car2 release]
// 这样导致car1的内存没有释放完毕，所以导致的内存泄漏，那么我们就应该在setCar 传入第二个值的时候先将第一个值释放（也就是此时_car中保存的地址release掉，这样就不会造成car1的内存泄漏）
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// set方法的内存管理（2）———— 同一个实例变量set两次，出现野指针（“僵尸对象复活”）
Person *p2=[[Person alloc]init];//p2 1
Car *car3=[[Car alloc]init];//car3 1
[p2 setCar:car3];//car3 2 (_car里面目前存的是car3的地址)
[p2 driver];
[p2 setCar:car3];//如果说setCar对同一个实例变量进行操作，也就是将car3 setCar了两次，那样的话car3 3 ，那样的话必然会造成car3的内存泄漏，所以说我们有必要进行一个if语句的判断，也就是如果传进来的参数地址和_car中的地址一致，那么就没有必要进行retain了。于是我们可以改进一下set方法。
[car3 release];
[p2 release];
/*
set方法的内存管理（3）———— set的写法（在手动管理内存的情况下）
（1）基本数据类型
-(void)setSpeed:(int)speed
{
_speed=speed;
}
（2））OC对象
-(void)setCar:(Car *)car
{
//①先判断_car和car表示的地址是否一致（也就是先看car是不是新传来的对象）
if(_car!=car)
{
//②对旧对象做一次release
[_car release];
//③对新对象做一次retain
_car=[car retain];
}
}
*/
}
return 0;
}
set方法的内存管理
代码：
#import <Foundation/Foundation.h>
@interface Car : NSObject
-(void)run;
@property int speed;
@end
@implementation Car
-(void)run
{
NSLog(@"car run!");
}
- (void)dealloc
{
NSLog(@"car dealloc!");
[super dealloc];
}
@end
@interface Person : NSObject
{
Car *_car;
}
-(void)driver;
-(void)setCar:(Car *)car;
@end
@implementation Person
//test1中运用到的set方法
//-(void)setCar:(Car *)car
//{
// [_car release];//release一下原来的内存（注意：如果是第一次调用set方法，_car里面是nil，nil!=car，不过此时也是可以调用[_car release];的，只是不起作用罢了～）
// _car=[car retain];//给car的计数+1，然后赋给_car（如果是第一次set，那么为什么这里要retain呢，因为必须让计数等于2，因为在main函数里，我们在[p release]; 和 [car release];各释放了一次car，所以-2的前提是要+2）
//}
//改进后的set方法
-(void)setCar:(Car *)car
{
// 如果 _car 和 car 相等，那么就无需做任何操作了，因为之前已经做过一次setCar了。如果对原值操作release和retain。那么就会出现野指针（“僵尸对象复活”）。所以只有传入的值和先前的值不一样，才会做下列操作：①release原值 ②_car=car; ③retain新值
if (_car!=car) {
[_car release];
_car=[car retain];
}
}
-(void)driver
{
[_car run];
}
- (void)dealloc
{
[_car release];//上节知识点，我们之前在setCar里面retain car了一次，所以必须让car的计数减1.所以要再Person里有Car的实例变量，若要释放car的内存，在Person的dealloc里面可以做到这一点。但是我们就没法在Car的dealloc里面释放Person了。
NSLog(@"person dealloc!");
[super dealloc];
}
@end
//在test1中暂时保存～需要时拿出来运行检验
void test1()
{
// set方法的内存管理（1）———— 原对象无法被释放造成的内存泄漏问题
// 创建Person的实例对象p
Person *p=[[Person alloc]init];//p 1
// 创建Car的实例对象car1
Car *car1=[[Car alloc]init];//car1 1
car1.speed=120;
// 将car1赋给p（p拥有了第一辆车car1）
[p setCar:car1];//car1 2（在set方法中retain了一下）
[p driver];//想要driver，就要给p的Car赋值～（你要先给他一辆车）
[car1 release];//car1用完了我们可以将car1释放掉，car1 1
// 创建Car的实例对象car2
Car *car2=[[Car alloc]init];//car2 1
// 将car2赋给p（p拥有的第二辆车car2）
[p setCar:car2];//car2 2
// 我们知道，在setCar中是这么一句话：_car=[car retain]; 在此处，没运行这句话之时，因为之前曾经调用的setCar，所以_car中存的是car1的内存地址。而运行到此处_car又变为了新的car2，car2变成了2，而car1还是1没变。
[car2 release];//car2 1
[p release];//p 0 car2 0 car1 1
// 这样看来，因为_car中的内存地址在两次setCar中发生了改变，导致本来意图在[p release]的同时想要[car1 release]，却[car2 release]
// 这样导致car1的内存没有释放完毕，所以导致的内存泄漏，那么我们就应该在setCar 传入第二个值的时候先将第一个值释放（也就是此时_car中保存的地址release掉，这样就不会造成car1的内存泄漏）
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// set方法的内存管理（2）———— 同一个实例变量set两次，出现野指针（“僵尸对象复活”）
Person *p2=[[Person alloc]init];//p2 1
Car *car3=[[Car alloc]init];//car3 1
[p2 setCar:car3];//car3 2 (_car里面目前存的是car3的地址)
[p2 driver];
[p2 setCar:car3];//如果说setCar对同一个实例变量进行操作，也就是将car3 setCar了两次，那样的话car3 3 ，那样的话必然会造成car3的内存泄漏，所以说我们有必要进行一个if语句的判断，也就是如果传进来的参数地址和_car中的地址一致，那么就没有必要进行retain了。于是我们可以改进一下set方法。
[car3 release];
[p2 release];
/*
set方法的内存管理（3）———— set的写法（在手动管理内存的情况下）
（1）基本数据类型
-(void)setSpeed:(int)speed
{
_speed=speed;
}
（2））OC对象
-(void)setCar:(Car *)car
{
//①先判断_car和car表示的地址是否一致（也就是先看car是不是新传来的对象）
if(_car!=car)
{
//②对旧对象做一次release
[_car release];
//③对新对象做一次retain
_car=[car retain];
}
}
*/
}
return 0;
}
版权声明：本文为博主原创文章，未经博主允许不得转载。
