总结copy和mutableCopy相关

其实我一直对于例如属性中的copy OR [array copy]这样的使用稀里糊涂的。之前有总结过，无奈现在又忘了。只能再理一遍了。
首先，我们知道，iOS中，不是所有的对象都支持copy、mutableCopy。
遵守NSCopying协议的类可以发送copy消息，遵守NSMutableCopying协议的类才可以发送mutablecopy消息。

顾名思义，copy就是复制了一个imutable的对象，而mutablecopy就是复制了一个mutable的对象。

一、非容器类对象（像NSString、NSNumber等一类的对象）

// 1、对一个非集合类对象的copy、mutableCopy
        NSString *string = @"abc";
        NSString *stringCopy = [string copy];
        NSMutableString *stringMutableCopy = [string mutableCopy];

        NSLog(@"%p",string);
        NSLog(@"%p",stringCopy);
        NSLog(@"%p",stringMutableCopy);

对imutable非集合类对象的copy、mutableCopy

可以看出:对一个iMutable的非集合类对象string，
调copy方法，其实复制的是string对象指向那块内存地址的指针，是指针拷贝，string 和stringCopy都是指向的同一块内存地址。
而调mutableCopy方法，复制的是string对象指向的那块内存地址的内容，是内容拷贝，stringMutableCopy重新指向一块内存地址，而这个内存地址保存的内容是从string指向的内存地址复制过来的,stringMutableCopy是一个可变对象。

// 2、对一个mutable非集合类对象的copy、mutableCopy
        NSMutableString *mutableString = [NSMutableString stringWithFormat:@"mutableString"];
        NSMutableString *mutableStringCopy = [mutableString copy];
        NSMutableString *mutableStringMutableCopy = [mutableString mutableCopy];
        [mutableStringMutableCopy appendString:@"AAA"];

对mutable非集合类对象的copy、mutableCopy

可以看出：对一个mutable的非集合类对象mutableString，
调copy方法，复制的是mutableString对象指向的那块内存地址的内容，是内容拷贝，但是得到的mutableStringCopy对象是一个不可变对象。
调mutableCopy方法，是内容拷贝，且得到的mutableStringMutableCopy对象是一个可变对象

总结

在非集合类对象中：对immutable对象进行copy操作，是指针复制，mutableCopy操作时内容复制；对mutable对象进行copy和mutableCopy都是内容复制。用代码简单表示如下：

• [immutableObject copy] // 浅复制

• [immutableObject mutableCopy] //深复制
• [mutableObject copy] //深复制
• [mutableObject mutableCopy] //深复制

二、集合类对象的copy与mutableCopy(像NSDictionary、NSArray、NSSet一类的对象)

// 1、对一个imutable Array的copy、mutableCopy        
            NSArray *array = @[@"A",@"B",@"C"];        
            NSArray *arrayCopy = [array copy];        
            NSMutableArray *arrayMutableCopy = [array mutableCopy];    
            [arrayMutableCopy addObject:@"D"];

对imutable Array的copy、mutableCopy

说明copy操作进行了指针拷贝，mutableCopy进行了内容拷贝。但需要强调的是：此处的内容拷贝，仅仅是拷贝array这个对象，array集合内部的元素仍然是指针拷贝。

arrayCopy和array是指针复制，是同一个NSArray对象（指向相同的对象），包括array里面的元素也是指向相同的指针
mutableArrayCopy是兑现复制，是array的可变副本，指向的对象和array不同。但是其中的元素和array中的元素指向的是同一个对象。mArrayCopy还可以修改自己的对象。
[mutableArrayCopy addObject:@“de”];
[mutableArrayCopy removeObjectAtIndex:0];//注意，容器内的元素内容都是指针复制

再看一个例子：

NSArray *array = [NSArray arrayWithObject:[NSMutableString stringWithString:@“a”],@“b”,@“c”,nil];

NSArray *arrayCopy = [array copy];
NSMutableArray *arrayMCopy = [array mutableCopy];
//arrayCopy、array指向的是同一个对象，arrayMCopy 不一样。但是其中的元素都是一样的对象（同一个指针）
NSMutableString *testString = [array objectAtIndex:0];

[testString appendString:@“tail”];//这样以上三个数组的首元素都被改变了

对于容器，其元素对象始终是指针复制。如果需要元素对象也是对象复制，就需要实现深拷贝：

NSArray *array = [NSArray arrayWithObjects:[NSMutableString stringWithString:@"first"],[NSStringstringWithString:@"b"],@"c",nil];    NSArray *deepCopyArray=[[NSArray alloc] initWithArray: array copyItems: YES];
NSArray* trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject: array]];

trueDeepCopyArray是完全意义上的深拷贝，而deepCopyArray则不是，对于deepCopyArray内的不可变元素其还是指针复制。或者我们自己实现深拷贝的方法。因为如果容器的某一元素是不可变的，那你复制完后该对象仍旧是不能改变的，因此只需要指针复制即可。除非你对容器内的元素重新赋值，否则指针复制即已足够。举个例子，[[array objectAtIndex:0]appendstring:@”sd”]后其他的容器内对象并不会受影响。[[array objectAtIndex:1]和[[deepCopyArray objectAtIndex:0]尽管是指向同一块内存，但是我们没有办法对其进行修改——因为它是不可改变的。所以指针复制已经足够。

// 2、对一个mutable Array的copy、mutableCopy        
NSMutableArray *mutableArray = [NSMutableArrayarrayWithObjects:@"A",@"B", nil];        
NSArray *mutableArrayCopy = [mutableArray copy];       
NSMutableArray *mutableArrayMutableCopy = [mutableArray mutableCopy];
[mutableArrayMutableCopy addObject:@"C"];

对mutable Array的copy、mutableCopy

内存地址不一样，说明对于mutable Array,调copy和调mutable方法都是进行内容拷贝，array集合内部的元素仍然是指针拷贝

三、自定义对象

当然在 ios 中并不是所有的对象都支持copy，mutableCopy，遵守NSCopying协议的类可以发送copy消息，遵守NSMutableCopying协议的类才可以发送mutableCopy消息。

假如发送了一个没有遵守上述两协议而发送copy或者 mutableCopy,那么就会发生异常。但是默认的ios类并没有遵守这两个协议。如果想自定义一下copy那么就必须遵守NSCopying,并且实现 copyWithZone:方法，如果想自定义一下mutableCopy那么就必须遵守NSMutableCopying,并且实现 mutableCopyWithZone:方法。

如果是我们定义的对象，那么我们自己要实现NSCopying,NSMutableCopying这样就能调用copy和mutablecopy了。举个例子：

@interface MyObj : NSObject
{
         NSMutableString *name;
         NSString *imutableStr;
         int age;
}
@property (nonatomic, retain) NSMutableString *name;
@property (nonatomic, retain) NSString *imutableStr;
@property (nonatomic) int age;
@end
@implementation MyObj
@synthesize name;
@synthesize age;
@synthesize imutableStr;
- (id)init
{
         if (self = [super init])
         {
                   self.name = [[NSMutableString alloc]init];
                   self.imutableStr = [[NSString alloc]init];
                   age = -1;
         }
         return self;
}
- (void)dealloc
{
         [name release];
         [imutableStr release];
         [super dealloc];
}
- (id)copyWithZone:(NSZone *)zone
{
         MyObj *copy = [[[self class] allocWithZone:zone] init];
         copy->name = [name copy];
         copy->imutableStr = [imutableStr copy];
//       copy->name = [name copyWithZone:zone];;
//       copy->imutableStr = [name copyWithZone:zone];//
         copy->age = age;
         return copy;
}
- (id)mutableCopyWithZone:(NSZone *)zone
{
         MyObj *copy = NSCopyObject(self, 0, zone);
         copy->name = [self.name mutableCopy];
         copy->age = age;
         return copy;

}

四、属性修饰符相关

如果property是NSString或NSArray及其子类的时候，最好选择使用copy。为什么？
这是为了防止赋值给它的是可变的数据，如果可变的数据发生了变化，那么该property也会发生变化。

@interface Person : NSObject
@property (strong, nonatomic) NSArray *bookArray1;
@property (copy, nonatomic) NSArray *bookArray2;
@end
@implementation Person
//省略setter方法
@end
//Person调用
main(){    
  NSMutableArray *books = [@[@"book1"] mutableCopy]; 
  Person *person = [[Person alloc] init];    
  person.bookArray1 = books;    
  person.bookArray2 = books;    
  [books addObject:@"book2"]; 
  NSLog(@"bookArray1:%@",person.bookArray1); 
  NSLog(@"bookArray2:%@",person.bookArray2);
}

我们看到，使用strong修饰的person.bookArray1输出是[book1,book2]，而使用copy修饰的person.bookArray2输出是[book1]。这下可以看出来区别了吧。

备注：使用strong，则person.bookArray1与可变数组books指向同一块内存区域，books内容改变，导致person.bookArray1的内容改变，因为两者是同一个东西；而使用copy，person.bookArray2在赋值之前，将books内容复制，创建一个新的内存区域，所以两者不是一回事，books的改变不会导致person.bookArray2的改变。
当源字符串是NSString时，由于字符串是不可变的，所以，不管是strong还是copy属性的对象，都是指向源对象，copy操作只是做了次浅拷贝。
当源字符串是NSMutableString时，strong属性只是增加了源字符串的引用计数，而copy属性则是对源字符串做了次深拷贝，产生一个新的对象，且copy属性对象指向这个新的对象。另外需要注意的是，这个copy属性对象的类型始终是NSString，而不是NSMutableString，因此其是不可变的。

这里还有一个性能问题，即在源字符串是NSMutableString，strong是单纯的增加对象的引用计数，而copy操作是执行了一次深拷贝，所以性能上会有所差异。而如果源字符串是NSString时，则没有这个问题。
所以，在声明NSString属性时，到底是选择strong还是copy，可以根据实际情况来定。不过，一般我们将对象声明为NSString时，都不希望它改变，所以大多数情况下，我们建议用copy，以免因可变字符串的修改导致的一些非预期问题

说到底，其实就是不同的修饰符，对应不同的setter方法，

1. strong对应的setter方法，是将_property先release（_property release），然后将参数retain（property retain），最后是_property = property。
2. copy对应的setter方法，是将_property先release（_property release），然后拷贝参数内容（property copy），创建一块新的内存地址，最后_property = property。

copy修饰的NSMutableArray属性(property)初始化问题

对于属性：

@property (nonatomic, copy) NSMutableArray *someArray;

若初始化时使用self.someArray：

self.someArray = [[NSMutableArray alloc] initWithCapacity:200];

当使用：

[self.someArray addObject:name];

APP Crash，其中关键 Error Info如下:

-[__NSArrayI addObject:]: unrecognized selector sent to instance 0x7f9c89701c20

原因是，通过copy修饰的property，若通过self.someArray ＝来赋值初始化，则是通过系统合成setter方法实现，由于设置copy修饰词，则返回实际上是不可变数组（NSArray）,当调用addObject 方法会报错。

初始化 或者 赋值 部分，做如下修改：

_someArray = [[NSMutableArray alloc] initWithCapacity:200];

则APP运行正常，原因是：
_someArray是实例变量，实例变量并没有 copy 修饰，指向的仍是定义的 NSMutableArray 类型。所以即使后面通过 self.someArray 使用 addObject方法仍然可行，因为初始化赋值阶段获取的是NSMutableArray类型对象
最佳解决方案: 其实，就是把copy修饰词改为strong,因为可变数组对象是个容器，只要其元素中没有和self对象存在相互持有造成内存泄漏的，则不会出现任何问题。

深拷贝、浅拷贝：

浅拷贝：
就是对内存地址的复制，让目标对象指针和源对象指向同一片内存空间。

浅拷贝只是对对象的简单拷贝，让几个对象共用一片内存，当内存销毁的时候，指向这片内存的几个指针需要重新定义才可以使用，要不然会成为野指针。
iOS里的浅拷贝：iOS里，使用retain关键字进行引用计数，就是一种更加保险的浅拷贝。他既让几个指针共用同一片内存空间，又可以在release由于计数的存在，不会轻易的销毁内存。
深拷贝：
深拷贝是指拷贝对象的具体内容，而内存地址是自主分配的，拷贝结束之后，两个对象虽然存的值是相同的，但是内存地址不一样，两个对象也互不影响，互不干涉。

copy与retain的区别：
copy是创建一个新对象，retain是创建一个指针，引用对象计数加一。 copy属性标识两个对象内容相同，新的对象retain count为1, 与旧有对象引用计数无关，旧有对象没有变化。copy减少对象对上下文的依赖。

深拷贝
iOS提供了copy和mutableCopy方法，顾名思义，copy就是复制了一个imutable的对象，而mutableCopy就是复制了一个mutable的对象。以下将举几个例子来说明。这里指的是NSString, NSNumber等等一类的对象。

NSString *string = @”dddd";
NSString *stringCopy = [string copy];
NSMutableString *stringDCopy = [string mutableCopy];
[stringMCopy appendString:@"!!"];

查看内存可以发现，string和stringCopy指向的是同一块内存区域(weak reference),引用计数没有发生改变。而stringMCopy则是我们所说的真正意义上的复制，系统为其分配了新内存，是两个独立的字符串内容是一样的。

说个题外话

如何理解NSString是不可变的，一旦创建就不能修改他。
NSString * string=@"aaaa";string=@“bbbb”;

意思是 这个地址的内容是不能变了,只能是aaaa
然后赋值是把string指向的地址变了,所以内容变了,地址不变内容是不能变地
NSMutableString 地址不变的情况下内容可以变的