OC学习深浅拷贝

浅拷贝：只拷贝引用(指针)， 不拷贝对象空间(不创建新的对象空间，只是使对象的引用计数器加1)

深拷贝：不拷贝引用，拷贝的是整个对象空间，即拷贝时会创建新的对象空间，空间内容和原来内容相同。

copy mutableCopy对于自定义对象是一样的

copy mutableCopy对于系统的基本类是有区别的

NSString NSMutableString NSArray NSMutableArray NSDictionary NSMutableDictionary NSSet NSMutableSet NSData NSMutableData

拷贝对象的时候要向对象发送copy或mutableCopy消息，执行copy或mutableCopy的对象必须要遵守NSCopying协议或NSMutableCopying协议，并实现里面的方法：copyWithZone:或mutableCopyWithZone:

系统的一些类之所以可以copy或mutableCopy，只因为这个类本身已经遵守了协议并实现了协方法，我们可以直接对其copy或mutableCopy, 但是我们自定义的类如果想要 copy ，就要遵守协议并实现协议方法。对于自定义的类或系统的其他类是没有可变和不可变之说的，copy和mutableCopy的功能是一样的。

系统类的copy

NSArray *array = [NSArray arrayWithObjects:@"one", @"two", nil];

NSLog(@"array == address: %p retainCount: %ld", array, array.retainCount);

NSArray *array2 = [array copy];

NSLog(@"array2 == address: %p retainCount: %ld", array2, array2.retainCount);

// Foundation基础类，字符串，数组，字典，集合，不可变类，调用copy，是浅拷贝，甚至可以理解为它的作用相当于retain

// 注意这里浅拷贝有两个条件：

// 第一是这些Foundation基础类

// 第二是不可变对象

// 第二是调用copy方法

NSMutableArray *mArr = [[NSMutableArray alloc] initWithObjects:@"dog", @"cat", nil];

NSLog(@"mArr == address: %p retainCount: %ld", mArr, mArr.retainCount);

NSMutableArray *mArr2 = [mArr copy];

NSLog(@"mArr2 == address: %p retainCount: %ld", mArr2, mArr2.retainCount);

// 总结：对于系统的这些可变对象，调用copy时，是深拷贝，对象的内容被copy

————————————————————————

自定义对象的copy

#import <Foundation/Foundation.h>

@interface Dog : NSObject <NSCopying, NSMutableCopying>

@property (nonatomic) NSInteger age;

@property (nonatomic) NSInteger height;

@end

#import "Dog.h"

@implementation Dog

// 调用copy的时候自动调用

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

    return [self retain]; // 不会创建新的对象，只是让对象的引用计数器加1

}

// 调用mutableCopy的时候自动调用

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

    return [self retain];

}

- (void)dealloc {

    NSLog(@"Dog dealloc");

    [super dealloc];

}

@end

#import <Foundation/Foundation.h>

#import "Dog.h"

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

    @autoreleasepool {

        Dog *dog = [[Dog alloc] init];

        dog.age = 2;

        dog.height = 170;

        NSLog(@"dog: %p retainCount: %ld", dog, dog.retainCount);

        Dog *newDog = [dog copy];

        NSLog(@"newDog: %p retainCount: %ld", newDog, newDog.retainCount);

    }

    return 0;

}

————————————————————————

对于自定义类的深拷贝，需要创建新的空间，并把原来的对象的属性赋给它即可，比如对于上面的示例，如果要对dog深拷贝，就要这样实现：

// 调用copy的时候自动调用

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

    // return [self retain]; // 不会创建新的对象，只是让对象的引用计数器加1

    Dog *copyDog = [[[self class] allocWithZone:zone] init];

    copyDog.age = self.age;

    copyDog.height = self.height;

    return copyDog;

}

// 调用mutableCopy的时候自动调用

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

    // return [self retain];

    Dog *copyDog = [[[self class] allocWithZone:zone] init];

    copyDog.age = self.age;

    copyDog.height = self.height;

    return copyDog;

}

————————————————————————

注意：在自定义类的拷贝中，对于浅拷贝，在拷贝过程中，如果对象内容(对象的属性)中有其他的对象引用(指针)，那么只拷贝指针引用，不拷贝指针指向的对象空间。对于深拷贝，如果对象内容（对象的属性）中有其他的对象引用，那么要拷贝掼针指向的对象空间，而不是引用。如果指针指向的对象又不其他对象指针，则继续拷贝空间，递归下去，直到拷贝到最后。那么如果有一个对象，对它深拷贝，就不仅要仅仅拷贝当前对象了，对象中如果有其他指引指向了另外一个对象，那么这个对象也应该继续深拷贝：

Car.h

#import <Foundation/Foundation.h>

#import "Engine.h"

@interface Car : NSObject <NSCopying>

@property (nonatomic) float speed;

@property (nonatomic, retain) Engine *engine;

@end

Car.m

#import "Car.h"

@implementation Car

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

    Car *copyCar = [[self class] allocWithZone:zone];

    copyCar.speed = self.speed;

    Engine *newEngine = [self.engine copy];

    copyCar.engine = newEngine;

    [newEngine release];

    // copyCar.engine = [[self.engine copy] autorelease];

    return copyCar;

}

- (void)dealloc {

    NSLog(@"car release");

    self.engine = nil;

    [super dealloc];

}

@end

Engine.h

#import <Foundation/Foundation.h>

@interface Engine : NSObject <NSCopying>

@property (nonatomic, copy) NSString *name;

@property (nonatomic) float weight;

@end

Engine.m

#import "Engine.h"

@implementation Engine

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

    Engine *copyEngine = [[[self class] allocWithZone:zone] init];

    copyEngine.name = self.name;

    copyEngine.weight = self.weight;

    return copyEngine;

}

- (void)dealloc {

    NSLog(@"engine release");

    self.name = nil;

    [super dealloc];

}

@end

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

    @autoreleasepool {

        Engine *engine = [[Engine alloc] init];

        Car *car = [[Car alloc] init];

        car.engine = engine;

        [engine release];

        NSLog(@"car == address: %p retainCount: %ld", car, car.retainCount);

        NSLog(@"car.engine == address: %p retainCount: %ld", car.engine, car.engine.retainCount);

        Car *copyCar = [car copy];

        NSLog(@"copyCar == address: %p retainCount: %ld", copyCar, copyCar.retainCount);

        NSLog(@"copyCar.engine == address: %p retainCount: %ld", copyCar.engine, copyCar.engine.retainCount);

        [car release];

        [copyCar release];

    }

    return 0;

}

car == address: 0x10011bfb0 retainCount: 1

car.engine == address: 0x10011bdb0 retainCount: 1

copyCar == address: 0x100401c90 retainCount: 1

copyCar.engine == address: 0x100401d30 retainCount: 1

car release

engine release

car release

engine release