OC中的浅拷贝和深拷贝

自己为了弄清楚这个问题引用了别人写的文章，都是转载挺多的几篇，但找不到具体出处，为了尊重原作者我先Mark一下。

这个问题涉及到：对象与指针的定义、可变对象与不可变对象、数值型变量赋值与指针型变量赋值的区别、对象引用计数机制及其原理

对象的拷贝分为浅拷贝和深拷贝，这与底层实现有关。浅拷贝就是只拷贝对象，但是属性不拷贝（不准确，要看包含的属性都有哪种数据类型。数值型的属性在赋值时是直接传值的，指针型的属性像字符串在赋值时是传的字符串的地址），拷贝出来的对象和原来的对象共用属性，即指向同一个属性地址（指的是指针型属性、变量），（原文意思解释：拷贝应该是开辟一块新的内存来存放被拷贝对象的副本，新对象的地址是新分配的跟被拷贝对象地址不一样，因为毕竟是新开辟的内存嘛，但是新对象内部的属性还是引用被拷贝对象的属性）。深拷贝则相当于不仅拷贝了一个对象还拷贝了它的属性，即完全是两个东西，只不过内容相同而已。

拷贝用到协议，如果这个类创建对象后，这个对象要被拷贝，那么这个类就需要用到拷贝协议，分两种：<NSCopying>和<NSMutableCopying>相当于一个是拷贝，另一个是拷贝后可修改。

（1）浅拷贝的案例。有一个Person类，它创建一个person1对象后，用person1再拷贝一个person2出来。

//Person类的Person.h文件
#import <Foundation/Foundation.h>
//因为这个类要支持拷贝，所以需要引入拷贝协议，有两种，后一种拷贝后可修改
@interface Person : NSObject<NSCopying,NSMutableCopying>
@property(nonatomic,copy) NSString* name;
@property(nonatomic,retain) NSNumber* age;//如果是int age；呢？
@end

//这是Person.m文件
#import "Person.h"
@implementation Person
//这是系统函数，可以直接拷贝过来
- (id)copyWithZone:(NSZone *)zone{
  Person *person=[[[self class]allocWithZone:zone]init]; //默认格式
  person.name=_name; //浅拷贝就是直接赋值即可
  person.age=_age;  //浅拷贝就是直接赋值即可
  return person;
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"//记得引入头文件
int main(int argc, const char * argv[])
{
  @autoreleasepool {
    Person *person1=[[Person alloc]init];
    person1.name=@"jack";
    person1.age=@18;
    Person *person2=[person1 copy];
    NSLog(@"%p,%p",person1,person2);//输入两个对象地址，不同
    NSLog(@"%p,%p",person1.age,person2.age);//输出两个对象的属性地址，相同
  }
  return 0;
}

结果：

0x1002036f0,0x100200330 //不同
0x1227,0x1227 //相同

（2）深拷贝的案例。

按道理是只需要把Person.m里面的赋值语句改成下面的样子，就能实现深拷贝：

person.name=[_name copy]; 
person.age=[_age copy];

但是，因为cocoa优化过了，所以有如下规则：

a：如果是Foundation框架里地不可变对象，就是Array，NSString等创建的对象，直接用copy来拷贝相当于retain，也就是属性还是同一个；

b：如果是用mutableCopy来拷贝，不管是可变还是不可变对象，属性神马的都直接拷贝了一份，即真正意义上得拷贝，它拷贝出来的对象统统都是可变的；

c：如果是可变对象，我们用copy也能实现真正意义上的拷贝，但是拷贝出来的对象是不可变的。

所以，我们拿name实验（因为age没有mutableCopy）实现语句的修改：

person.name=[_name mutableCopy]
person.age=[_age copy];

然后再输出person1和person2的name属性的地址，发现就不同了。

总结：

浅拷贝和深拷贝在实际项目中不常用，可以做一般了解。

***********************************************************************************************************************************************************************

《第一篇》

      浅 复 制：在复制操作时，对于被复制的对象的每一层复制都是指针复制。

    深 复 制：在复制操作时，对于被复制的对象至少有一层复制是对象复制。

   完全复制：在复制操作时，对于被复制的对象的每一层复制都是对象复制。

        注：1、在复制操作时，对于对象有n层是对象复制，我们可称作n级深复制，此处n应大于等于1。

              2、对于完全复制如何实现（目前通用的办法是：迭代法和归档），这里后续是否添加视情况而定，

              暂时不做讲解。

          3、指针复制俗称指针拷贝，对象复制也俗称内容拷贝。

          4、一般来讲，

                 浅层复制：复制引用对象的指针。

 

               深层复制：复制引用对象内容。

            这种定义在多层复制的时候，就显得模糊。所以本文定义与它并不矛盾。

            反而是对它的进一步理解和说明。           

retain：始终是浅复制。引用计数每次加一。返回对象是否可变与被复制的对象保持一致。

copy：对于可变对象为深复制，引用计数不改变;

对于不可变对象是浅复制，引用计数每次加一。始终返回一个不可变对象。

mutableCopy：始终是深复制，引用计数不改变。始终返回一个可变对象。

不可变对象：值发生改变，其内存首地址随之改变。

   可变对象：无论值是否改变，其内存首地址都不随之改变。

   引用计数：为了让使用者清楚的知道，该对象有多少个拥有者（即有多少个指针指向同一内存地址）。

 

 最近有一个好朋友问我，什么时候用到深浅复制呢？那么我就把我所总结的一些分享给大家，希望能帮助你们更好的理解深浅复制！

那么先让我们来看一看下边数组类型的转换

1、不可变对象→可变对象的转换：因为新的对象是可变的，肯定不是引用原来的对象

       NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];

       NSMutableArray  *str2=[array1 mutableCopy];

2、可变对象→不可变对象的转换：因为新的对象是不可变的，不是引用原来的对象

    NSMutableArray *array2   = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];

       NSArray *array1=[  array2    Copy];

3、可变对象→可变对象的转换（不同指针变量指向不同的内存地址）：。。。

       NSMutableArray *array1= [NSMutableArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];

       NSMutableArray  *str2=[array1 mutableCopy];

通过上边的两个例子，我们可轻松的将一个对象在可变和不可变之间转换，并且这里不用考虑内存使用原则（即引用计数的问题）。没错，这就是深拷贝的魅力了。

4、同类型对象之间的指针复制（不同指针变量指向同一块内存地址）：

  a、

   NSMutableString *str1=[NSMutableString stringWithString:@"two day"];

   NSMutableString *str2=[str1   retain];

   [str1  release];

  b、

   NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];

   NSArray  *str2=[array1 Copy];

   [array1 release];

 

   通俗的讲，多个指针同时指向同一块内存区域，那么这些个指针同时拥有对该内存区的所有权。所有权的瓜分过程，这时候就要用到浅拷贝了。

则简化为：

问：什么时候用到深浅拷贝？

答：深拷贝是在要将一个对象从可变（不可变）转为不可变（可变）或者将一个对象内容克隆一份时用到；

     浅拷贝是在要复制一个对象的指针时用到。

 

亲爱的读者朋友，下面是我用于验证的详细代码。对于验证还能得出什么结论，我希望朋友们能自己多多发掘一下。这里只做以上几点总结。对于本文有任何疑问请与我联系，欢迎指出本文不足的地方，谢谢！

 #import<Foundation/Foundation.h>

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

{

    @autoreleasepool {

 

    ===========================第一种：非容器类不可变对象==================

  

        NSString *str1=@"one day";

        

          printf("\n初始化赋值引用计数为::::%lu",str1.retainCount);

        NSString *strCopy1=[str1 retain];

          printf("\n继续retain引用计数为:::%lu",str1.retainCount);

        NSString *strCopy2=[str1 copy];

          printf("\n继续copy后引用计数为::::%lu",str1.retainCount);

        NSString *strCopy3=[str1 mutableCopy];

                printf("\n继续mutableCopy后为:::%lu\n",str1.retainCount);

        

        printf("\n非容器类不可变对象\n原始地址::::::::::%p",str1);

        printf("\nretain复制::::::::%p",strCopy1);

        printf("\ncopy复制::::::::::%p",strCopy2);

        printf("\nmutableCopy复制:::%p",strCopy3);

    //这里说明该类型不存在引用计数的概念

  // 初始化赋值引用计数为：18446744073709551615

  // 继续retain引用计数为：18446744073709551615

  // 继续copy后引用计数为：18446744073709551615

  // 继续mutableCopy后为：18446744073709551615

 小提示：这里很多人都说是赋值，所以就好解释这里没引用计数的概念。而且也能解释为什么

         NSString *strCopy2=[str1 copy];

         NSMutableString  *strCopy2=[str1 copy]; 

         这样都不会报错的原因了。那既然只是简单赋值为什么要这么麻烦呢，直接

         NSString *strCopy2=*str1;

         NSMutableString  *strCopy2=*str1;

         其实大家都看出来了，这里是指针变量，只存在“指针的复制”，

         跟赋值概念完全不同，虽然这里看起来很像。

         原来该类型是字符串常量时，系统会为我们优化，声明了多个字符串，

              但是都是常量，且内容相等，那么系统就只为我们申请一块空间。

  疑问： 深复制=浅复制+赋值吗？ 

         赋值过程：输入数据→寄存器处理→开辟内存→写入数据。

         一次深复制，可以得到被复制对象指针，并进行一次赋值操作。

   //非容器类不可变对象

   //原始地址::::::::::0x1000033d0

   //retain复制::::::::0x1000033d0//浅复制

   //copy复制::::::::::0x1000033d0//浅复制

   //mutableCopy复制:::0x10010c420//深复制

   

      printf("\n");

 

 ==============================第二种：容器类不可变对象=================

    

   NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];

        

          printf("\n初始化赋值引用计数为::::::::::::%lu",array1.retainCount);

        NSArray *arrayCopy1 = [array1 retain];

          printf("\n继续retain后引用计数为:::::::::%lu",array1.retainCount);

        NSArray *arrayCopy2 = [array1 copy];

          printf("\n继续copy后引用计数为:::::::::::%lu",array1.retainCount);

        NSArray *arrayCopy3 = [array1 mutableCopy];

          printf("\n继续mutableCopy后引用计数为::::%lu\n",array1.retainCount);

        

    printf("\n容器类不可变数组\n原始地址::::::::::%p\t\t%p",array1,[array1 objectAtIndex:1]);

        printf("\nretain复制::::::::%p\t%p",arrayCopy1,[arrayCopy1 objectAtIndex:1]);

        printf("\ncopy复制::::::::::%p\t%p",arrayCopy2,[arrayCopy2 objectAtIndex:1]);

        printf("\nmutableCopy复制:::%p\t%p",arrayCopy3,[arrayCopy3 objectAtIndex:1]);

        

   

    //初始化赋值引用计数为::::::::::::1

    //继续retain后引用计数为:::::::::2

    //继续copy后引用计数为:::::::::::3

    //继续mutableCopy后引用计数为::::3

    //容器类不可变数组

    //原始地址::::::::::0x10010c6b0 0x100003410

    //retain复制::::::::0x10010c6b0 0x100003410//浅复制

    //copy复制::::::::::0x10010c6b0 0x100003410//浅复制

    //mutableCopy复制:::0x10010c760 0x100003410//深复制

    

        printf("\n");

 

 

 

 ===============第三种：非容器类可变对象==================

      

 NSMutableString *str2=[NSMutableString stringWithString:@"two day"];

        

          printf("\n初始化赋值引用计数为::::::::::::%lu",str2.retainCount);

        NSMutableString *strCpy1=[str2 retain];

          printf("\n继续retain后引用计数为:::::::::%lu",str2.retainCount);

        NSMutableString *strCpy2=[str2 copy];

          printf("\n继续copy后引用计数为:::::::::::%lu",str2.retainCount);

        NSMutableString *strCpy3=[str2 mutableCopy];

                printf("\n继续mutableCopy后引用计数为::::%lu\n",str2.retainCount);

        

        printf("\n非容器类可变对象\n原始地址::::::::::%p",str2);

        printf("\nretin复制::::::::%p",strCpy1);

        printf("\ncopy复制::::::::::%p",strCpy2);

        printf("\nmutableCopy复制:::%p",strCpy3);

       

 

         //初始化赋值引用计数为::::::::::::1

         //继续retain后引用计数为:::::::::2

         //继续copy后引用计数为:::::::::::2

         //继续mutableCopy后引用计数为::::2

         //非容器类可变对象

         //原始地址::::::::::0x10010c560

         //retain复制::::::::0x10010c560//浅复制

         //copy复制::::::::::0x100102720//深复制

       //mutableCopy复制:::0x10010c880//深复制

         

        printf("\n");

 

 

 

 =========================第四种：容器类可变对象======================

 

 NSMutableArray *array2   = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];

        

         printf("\n初始化赋值引用计数为::::::::::%lu",array2.retainCount);

       NSMutableArray *arrayCpy1 = [array2 retain];

         printf("\n继续retain后引用计数为:::::::%lu",array2.retainCount);

       NSMutableArray *arrayCpy2=[array2 copy];

         printf("\n继续copy后引用计数为:::::::::%lu",array2.retainCount);

       NSMutableArray *arrayCpy3 = [array2 mutableCopy];

         printf("\n继续mutableCopy后引用计数为::%lu\n",array2.retainCount);

        

       printf("\n容器类可变数组\n原始地址:::::::::::%p\t%p",array2,[array2 objectAtIndex:1]);

       printf("\nretain复制:::::::::%p\t%p",arrayCpy1,[arrayCpy1 objectAtIndex:1]);

       printf("\ncopy复制:::::::::::%p\t%p",arrayCpy2,[arrayCpy2 objectAtIndex:1]);

       printf("\nnmutableCopy复制:::%p\t%p",arrayCpy3,[arrayCpy3 objectAtIndex:1]);

       

        

         //初始化赋值引用计数为::::::::::1

         //继续retain后引用计数为:::::::2

         //继续copy后引用计数为:::::::::2

         //继续mutableCopy后引用计数为::2

         //容器类可变数组

         //原始地址:::::::::::0x10010e6c0 0x1000034b0

         //retain复制:::::::::0x10010e6c0 0x1000034b0//浅复制

         //copy复制:::::::::::0x10010e790 0x1000034b0//深复制

         //nmutableCopy复制:::0x10010e7c0 0x1000034b0//深复制

         

        

    }

    return 0;

}

*********************************************************************************************

《第二篇》

在Objective-C中,一个对象可以调用copy或mutableCopy方法来创建一个副本对象,本文着重讲解如何正确使用copy的功能.

iOS  OC  copy  深复制  浅复制

    首先，什么是copy？

    Copy的字面意思是“复制”、“拷贝”，是一个产生副本的过程。

    常见的复制有：文件复制，作用是利用一个源文件产生一个副本文件。

    特点：1、修改源文件的内容，不会影响副本文件；

             2、修改副本文件的内容，不会影响源文件。

    OC中copy的作用是：利用一个源对象产生一个副本对象

    特点：1、修改源对象的属性和行为，不会影响副本对象；

             2、修改副本对象的属性和行为，不会影响源对象。

    如何使用copy功能？

    一个对象可以调用copy或mutableCopy方法来创建一个副本对象。

    1、copy：创建的时不可变副本（如NSString、NSArray、NSDictionary）。

    2、mutableCopy：创建的可变副本（如NSMutableString、NSMutableArray、NSMutableDictionary）。

    使用copy功能的前提：

    1、copy：需要遵守NSCopying协议，实现copyWithZone：方法。

    @protocol NSCopying

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

      @end

      2、mutableCopy : 需要遵守NSMutableCopying协议，实现mutableCopyWithZone:方法

      @protocol NSMutableCopying

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

      @end 

      深复制和浅复制的区别：

      深复制(深拷贝、内容拷贝、deep copy):

      特点：1、源对象和副本对象是不同的两个对象； 

               2、源对象引用计数器不变，副本对象计数器为1（因为是新产生的）。

      本质：产生了新对象。

      浅复制(浅拷贝、指针拷贝、shallow copy):

      特点：1、源对象和副本对象是同一对象； 

               2、源对象（副本对象）引用计数器+1，相当于做一次retain操作。

      本质：没有产生新对象。

      常见的复制如下图：    

    

      只有源对象和副本对象都不可变时，才是浅复制，其他都是深复制。

      关于区分深复制与浅复制的一些详细代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

/**   NSMutableString调用mutableCopy ： 深复制   */ void  mutableStringMutableCopy() {      NSMutableString *srcStr = [NSMutableString stringWithFormat:@ "age is %d" , 10];      NSMutableString *copyStr = [srcStr mutableCopy];            [copyStr appendString:@ "abc" ];            NSLog(@ "srcStr=%@, copyStr=%@" , srcStr, copyStr); }   /**   NSMutableString调用copy ： 深复制   */ void  mutableStringCopy() {      NSMutableString *srcStr = [NSMutableString stringWithFormat:@ "age is %d" , 10];            NSString *copyStr = [srcStr copy];                  [srcStr appendString:@ "abc" ];            NSLog(@ "srcStr=%p, copyStr=%p" , srcStr, copyStr); }   /**   NSString调用mutableCopy ： 深复制   */ void  stringMutableCopy() {      NSString *srcStr = [NSString stringWithFormat:@ "age is %d" , 10];            NSMutableString *copyStr =  [srcStr mutableCopy];      [copyStr appendString:@ "abc" ];            NSLog(@ "srcStr=%@, copyStr=%@" , srcStr, copyStr); }   /**   NSString调用copy : 浅复制   */ void  stringCopy() {      //  copy ： 产生的肯定是不可变副本            //  如果是不可变对象调用copy方法产出不可变副本，那么不会产生新的对象      NSString *srcStr = [NSString stringWithFormat:@ "age is %d" , 10];      NSString *copyStr = [srcStr copy];            NSLog(@ "%p %p" , srcStr, copyStr); }

     @property内存管理策略的选择

      1.非ARC

      1> copy : 只用于NSString\block；

      2> retain : 除NSString\block以外的OC对象；

   3> assign : 基本数据类型、枚举、结构体（非OC对象），当2个对象相互引用，一端用retain，一端                     用assign。

 

      2.ARC

      1> copy : 只用于NSString\block；

      2> strong : 除NSString\block以外的OC对象；

      3> weak : 当2个对象相互引用，一端用strong，一端用weak；

   4> assgin : 基本数据类型、枚举、结构体（非OC对象）。

**************************************************************************************************************************************************

《第三篇》

首先关于copy和mutableCopy的行为：不管是NSString这种元素类、还是NSArray这样的容器类、还是Mutable和非Mutable类，copy和mutableCopy调用后表现的行为到底是什么样完成取决于类本身NSCopying和NSMutableCopying协议是如何实现的。

想要正常调用copy和mutableCopy两个函数，那么类就一定要实现对应的协议。

1.      元素数据的copy和mutableCopy。

常用的NSString类，示例代码如下：

[cpp]  view plain copy

1. NSString* string = @”a”;  
2. NSString* stringCopy = [string copy];// stringCopy与string地址相同，retainCount+ 1  
3. NSMutableString* stringMCopy = [string mutablecopy];// stringMCopy与string地址不同  
4.    
5. NSMutableString* stringM1 = [stringMCopy copy];//地址与stringMCopy不同，且为不可修改  
6. NSMutableString* stringM2 = [stringMCopy mutablecopy];//地址与stringMCopy不同，可修改   

可以基本推出NSString和NSMutableString中两个协议的实现

 

[cpp]  view plain copy

1. NSString：  
2. - (id)copywithZone:(NSZone*)zone  
3. {  
4.   return self;  
5. }  
6.    
7. - (id)mutableCopywithZone:(NSZone*)zone  
8. {  
9.   NSMutableString* copy =[[NSMutableString alloc] initxxxxxx];  
10.   ....  
11.   return copy;  
12. }  
13. NSMutableString:  
14. - (id)copywithZone:(NSZone*)zone  
15. {  
16.   NSString* copy = [[NSStringalloc] initxxxxxx];  
17.   ....  
18.   return copy;//所以不可修改  
19. }  
20.    
21. - (id)mutableCopywithZone:(NSZone*)zone  
22. {  
23.   NSMutableString* copy =[[NSMutableString alloc] initxxxxxx];  
24.   ....  
25.   return copy;  
26. }  

2.      容器类的copy和mutableCopy。

常用类NSArray和NSMutableArray，看如下示例代码：

[cpp]  view plain copy

1. Class1* obj1= ....;//正常初始化  
2. NSArray* array = [[NSArray alloc] initWithObjects:obj1, nil];  
3. NSArray* arrayCopy = [array copy];//地址不变，retaincount+1  
4. NSMutableArray* arrayMCopy = [array mutableCopy];//地址改变，但是数组中成员指针和obj1相同，浅拷贝  
5.   
6. NSMutableArray* arrayM1 = [arrayMCopy Copy];//地址改变，但是数组中成员指针和obj1相同，浅拷贝。arrayM1为NSArray不可修改  
7. NSMutableArray* arrayM2 = [arrayMCopy mutableCopy];//地址改变，但是数组中成员指针和obj1相同，浅拷贝  

[cpp]  view plain copy

1. //推断  

[cpp]  view plain copy

1. NSArray：  
2. - (id)copywithZone:(NSZone*)zone  
3. {  
4.   //伪码  
5.   return [self retain];  
6. }  
7.   
8. - (id)mutableCopywithZone:(NSZone*)zone  
9. {  
10.   NSMutableArray* copy = [[NSMutableString alloc] initxxxxxx];  
11.   for (id element in self) {  
12.     [copy addObject:element];//element retian count + 1  
13.     ....  
14.   }  
15.   return copy;  
16. }  
17.   
18. NSMutableArray:  
19. - (id)copywithZone:(NSZone*)zone  
20. {  
21.   NSArray* copy = [[NSArray alloc] initXXX];  
22.   /*把每个element加入到copy数组，retainCount+1*/  
23.   ....  
24.   return copy;  
25. }  
26.   
27. - (id)mutableCopywithZone:(NSZone*)zone  
28. {  
29.   NSMutableArray* copy = [[NSMutableString alloc] initxxxxxx];  
30.   for (id element in self) {  
31.     [copy addObject:element];//element retian count + 1  
32.     ....  
33.   }  
34.   return copy;  
35. }  

3.      深拷贝

上面提到的官方文档中介绍两种实现深拷贝的方法：

a.      用Array的initWithArray:  copyItems函数，如下：

NSArray *deepCopyArray=[[NSArray alloc] initWithArray: someArraycopyItems: YES];

调用后，会对原NSArray中的每个元素调用其copy函数，并把返回的id加入到新的数组中。所以这是依赖于Obj对象类实现的深拷贝，如果- (id)copywithZone:(NSZone*)zone是重新分配一块内存赋值后返回，那么就是真正的深拷贝。如果直接返回自身，那么它只是浅拷贝。

b.      用archiver方式：

NSArray* trueDeepCopyArray = [NSKeyedUnarchiverunarchiveObjectWithData: [NSKeyedArchiver archivedDataWithRootObject:oldArray]];

这是真正意义上的深拷贝，不依赖于实际类Copying协议的实现。

 

4. 用Category实现自定义的深拷贝deepmutableCopy，如：

[cpp]  view plain copy

1. - (NSMutableArray *)mutableDeepCopy  
2. {  
3.     NSMutableArray *ret = [[NSMutableArrayalloc] initWithCapacity:[self count]];  
4.     for (id value in self)  
5.     {  
6.         id oneCopy = nil;  
7.         if ([value respondsToSelector:@selector(mutableDeepCopy)])  
8.             oneCopy = [value mutableDeepCopy];  
9.         else if ([value respondsToSelector:@selector(mutableCopy)])  
10.             oneCopy = [value mutableCopy];  
11.         if (oneCopy == nil)  
12.             oneCopy = [value copy];  
13.         [ret addObject: oneCopy];  
14.     }  
15.     return ret;  
16. }  

******************************************

《第四篇》

[cpp]  view plain copy

1. #import <Foundation/Foundation.h>  
2.   
3. int main(int argc, const char * argv[])  
4. {  
5.   
6.     @autoreleasepool {  
7.           
8.         NSMutableArray *dataArray = [NSMutableArray arrayWithObjects:  
9.                                      [NSMutableString stringWithString:@"one"],  
10.                                      [NSMutableString stringWithString:@"two"],  
11.                                      [NSMutableString stringWithString:@"three"],  
12.                                      nil  
13.                                      ];  
14.         NSMutableArray *dataArray2;  
15.         NSMutableString *mStr;  
16.           
17.         NSLog(@"dataArray:   ");  
18.         for(NSString *elem in dataArray)  
19.             NSLog(@"   %@", elem);  
20.           
21.         //执行一个拷贝，然后改变其中的一个字符串(浅复制)  
22.         dataArray2 = [dataArray mutableCopy];  
23.           
24.         //这种方式会同时改变连个数组中的对象  
25.         mStr = [dataArray objectAtIndex:0];  
26.         [mStr appendString:@"ONE"];  
27.                   
28.         NSLog(@"dataArray:");  
29.         for(NSString *elem in dataArray)  
30.             NSLog(@"  %@",elem);  
31.           
32.         NSLog(@"dataArray2:");  
33.         for(NSString *elem in dataArray2)  
34.             NSLog(@"  %@",elem);  
35.           
36.         [dataArray2 release];  
37.     }  
38.     return 0;  
39. }  

使用上述方法的执行结果如下：

注意：原始数组及其副本中的第一个元素的值：他们都被修改了。为什么会产生这样的结果呢？

或许你能理解为什么dataArray的第一个元素发生改变，但是不明白为什么它的副本也会改变。

这与默认的浅复制方式有关。它意味着使用mutableCopy方式复制数组时，在内存中为新的数组对象分配了空间，并且将单个元素复制到新的数组中。然而将原始数组中每个元素复制到新位置意味着：仅将引用从一个数组元素复制到另一个数组元素。这样做的最终结果，就是这两个数组中的元素都指向内存中的同一个字符串。这与将一个对象赋值给另一个对象没有什么不同。

要为数组中每个元素创建完全不同的副本，需要执行所谓的深复制。这就意味着要创建数组中的每个对象内容的副本，而不仅是这些对象的引用的副本（并且考虑一下，如果一个数组中的元素本身是数组对象时，深复制意味着该如何处理？）

假设想要更改其中一个集合而不是他的副本，那么可能要为单个元素创建自己的副本。例如假设想要更改代码中的dataArray2的第一个元素，但不更改dataArray的第一个元素，可以创建一个新的字符串（使用stringWithString：之类的方法）并将它存储到dataArray2的第一个位置，如下所示：

[cpp]  view plain copy

1. //这种方式只会改变一个数组中的对象，而对另外一个没有影响  
2.         mStr = [NSMutableString stringWithString:[dataArray2 objectAtIndex:0]];  
3.         [mStr appendString:@"ONE"];  
4.         [dataArray2 replaceObjectAtIndex:0 withObject:mStr];  

如果顺利的话，你会发现即使替换了数组中的对象之后，mStr和dataArray2的第一个元素仍指向内存中的同一个对象。这意味着随后在程序中对mStr做的任何修改，也将会更改数组 的第一个元素。如果这不是你想要的，则可以总是释放mStr，并分配新实例，因为对象会被replaceObject：atIndex：withObject：方法自动保持。