浅析ObjectiveC 深浅拷贝学习

移动开发 iOS
Objective C是一个不错的开发语言,Objective-C不支援运算子多载,与C++不同,但和Java相同,Objective C只容许对象继承一个类别(不设多重继承)。

iPhone开发语言Objective-C是一种简单的计算机语言,简称OC,支持复杂南通的面向对象编程。Objective C语言,通常写作ObjC和较少用的Objective C或Obj-C,是扩充C的面向对象编程语言。它主要使用于Mac OS X和GNUstep这两个使用OpenStep标准的系统,而在NeXTSTEP和OpenStep中它更是基本语言。Objective C可以在gcc运作的系统写和编译,因为gcc含Objective C的编译器。

在ObjectiveC 中,什么是深浅拷贝? 深浅拷贝分别指深拷贝和浅拷贝,即mutableCopy和copy方法。

 

copy复制一个不可变对象,而mutableCopy复制一个mutable可变对象。

什么时候用到深浅拷贝?下面举几个例子说明。 非容器类对象 如NSString,NSNumber等一类对象  

示例1:

  1. // 非容器类对象     NSString *str = @"origin string";  
  2.    NSString *strCopy = [str copy];  
  3.    NSMutableString *mstrCopy = [str mutableCopy];  
  4.    [mstrCopy appendString:@"??"]; 

查看内存可以发现,str和strCopy指向的是同一块内存区域,我们称之为弱引用(weak reference)。而mstrCopy是真正的复制,系统为其分配了新内存空间,保存从str复制过来的字符串值。从最后一行代码中修改这些值而不影响str和strCopy中可证明。

示例2:

  1. NSMutableString *mstr = [NSMutableString stringWithString:@"origin"];  
  2.    NSString *strCopy = [mstr copy];  
  3.    NSMutableString *mstrCopy = [mstr copy];  
  4.    NSMutableString *mstrMCopy = [mstr mutableCopy];  
  5.    //[mstrCopy appendString:@"1111"];  //error  
  6.    [mstr appendString:@"222"];  
  7.    [mstrMCopy appendString:@"333"]; 

以上四个对象所分配的内存都是不一样的。而且对于mstrCopy,它所指向的其实是一个imutable对象,是不可改变的,所以会出错。这点要注意,好好理解。

容器类对象深浅复制

比如NSArray,NSDictionary等。对于容器类本身,上面讨论的结论也适用的,下面探讨的是复制后容器内对象的变化。

示例3

  1. /* copy返回不可变对象,mutablecopy返回可变对象 */   
  2.  
  3.       
  4.     NSArray *array1     = [NSArray arrayWithObjects:@"a",@"b",@"c",nil];  
  5.     NSArray *arrayCopy1 = [array1 copy];  
  6.     //arrayCopy1是和array同一个NSArray对象(指向相同的对象),包括array里面的元素也是指向相同的指针  
  7.     NSLog(@"array1 retain count: %d",[array1 retainCount]);  
  8.     NSLog(@"array1 retain count: %d",[arrayCopy1 retainCount]);  
  9.       
  10.     NSMutableArray *mArrayCopy1 = [array1 mutableCopy];  
  11.     //mArrayCopy1是array1的可变副本,指向的对象和array1不同,但是其中的元素和array1中的元素指向的还是同一个对象。mArrayCopy1还可以修改自己的对象  
  12.     [mArrayCopy1 addObject:@"de"];  
  13.     [mArrayCopy1 removeObjectAtIndex:0]; 

array1和arrayCopy1是指针复制,而mArrayCopy1是对象复制,符合前面示例1讨论的结论。mArrayCopy1可以改变其内的元素:删除或添加。但容器内的元素内容都是浅拷贝。

示例4

  1. NSArray *mArray1 = [NSArray arrayWithObjects:[NSMutableString stringWithString:@"a"],@"b",@"c",nil];  
  2.     NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);  
  3.     NSArray *mArrayCopy2 = [mArray1 copy];  
  4.     NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);  
  5.     // mArray1和mArrayCopy2指向同一对象,retain值+1。  
  6.       
  7.     NSMutableArray *mArrayMCopy1 = [mArray1 mutableCopy];  
  8.     NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);     //mArrayCopy2和mArray1指向的是不一样的对象,但是其中的元素都是一样的对象——同一个指针  
  9.  
  10.     NSMutableString *testString = [mArray1 objectAtIndex:0];   
  11.  
  12.     //testString = @"1a1";//这样会改变testString的指针,其实是将@“1a1”临时对象赋给了testString  
  13.     [testString appendString:@" tail"];//这样以上三个数组的首元素都被改变了 

由此可见,对于容器而言,其元素对象始终是指针复制。如果需要元素对象也是对象复制,就需要实现深拷贝。http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Collections/Articles/Copying.html

示例5

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

trueDeepCopyArray是完全意义上的深拷贝,而deepCopyArray则不是,对于deepCopyArray内的不可变元素其还是指针复制。

或者我们自己实现深拷贝的方法。因为如果容器的某一元素是不可变的,那你复制完后该对象仍旧是不能改变的,因此只需要指针复制即可。除非你对容器内的元素重新赋值,否则指针复制即已足够。

举个例子,[[array objectAtIndex:0]appendstring:@”sd”]后其他的容器内对象并不会受影响。[[array objectAtIndex:1]和[[deepCopyArray

objectAtIndex:0]尽管是指向同一块内存,但是我们没有办法对其进行修改——因为它是不可改变的。所以指针复制已经足够。所以这并不是完全意义上的深拷贝。

自己实现深拷贝的方法

NSDictionaryMutableDeepCopy.h
 

  1. 8 #import <foundation /Foundation.h> 
  2. @interface NSDictionary(MutableDeepCopy)  
  3. - (NSMutableDictionary *)mutableDeepCopy;  
  4. @end  
  5. </foundation> 
  6. NSDictionaryMutableDeepCopy.m  
  7. #import "NSDictionaryMutableDeepCopy.h"  
  8. @implementation NSDictionary(MutableDeepCopy)  
  9. - (NSMutableDictionary *)mutableDeepCopy {  
  10.     NSMutableDictionary *ret = [[NSMutableDictionary alloc]  
  11.                                 initWithCapacity:[self count]];  
  12.     NSArray *keys = [self allKeys];  
  13.     for (id key in keys) {  
  14.         id oneValue = [self valueForKey:key];  
  15.         id oneCopy = nil;          
  16.         if ([oneValue respondsToSelector:@selector(mutableDeepCopy)]) {  
  17.             oneCopy = [oneValue mutableDeepCopy];  
  18.         }  
  19.         else if ([oneValue respondsToSelector:@selector(mutableCopy)]) {  
  20.             oneCopy = [oneValue mutableCopy];  
  21.         }  
  22.         if (oneCopy == nil) {  
  23.             oneCopy = [oneValue copy];  
  24.         }  
  25.         [ret setValue:oneCopy forKey:key];  
  26.     }  
  27.     return ret;  
  28. }  
  29. @end 

使用类别方法来实现。

自定义对象  

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

  1. @interface MyObj : NSObject<nscopying ,NSMutableCopying> 
  2. {  
  3.          NSMutableString *name;  
  4.          NSString *imutableStr;  
  5.          int age;  
  6. }  
  7. @property (nonatomic, retain) NSMutableString *name;  
  8. @property (nonatomic, retain) NSString *imutableStr;  
  9. @property (nonatomic) int age;  
  10.    
  11. @end  
  12.  
  13. @implementation MyObj  
  14. @synthesize name;  
  15. @synthesize age;  
  16. @synthesize imutableStr;  
  17. - (id)init  
  18. {  
  19.          if (self = [super init])  
  20.          {  
  21.                    self.name = [[NSMutableString alloc]init];  
  22.                    self.imutableStr = [[NSString alloc]init];  
  23.                    age = -1;  
  24.          }  
  25.          return self;  
  26. }  
  27. - (void)dealloc  
  28. {  
  29.          [name release];  
  30.          [imutableStr release];  
  31.          [super dealloc];  
  32. }  
  33. - (id)copyWithZone:(NSZone *)zone  
  34. {  
  35.          MyObj *copy = [[[self class] allocWithZone:zone] init];  
  36.          copy->name = [name copy];  
  37.          copy->imutableStr = [imutableStr copy];  
  38. //       copy->name = [name copyWithZone:zone];;  
  39. //       copy->imutableStr = [name copyWithZone:zone];//  
  40.          copy->ageage = age;  
  41.    
  42.          return copy;  
  43. }  
  44. - (id)mutableCopyWithZone:(NSZone *)zone  
  45. {  
  46.          MyObj *copy = NSCopyObject(self, 0, zone);  
  47.          copy->name = [self.name mutableCopy];  
  48.          copy->ageage = age;  
  49.          return copy;  
  50. }  
  51. @end  
  52. </nscopying>  

小结:

对于非容器类对象,有:

如果对一个不可变对象复制,copy是指针复制,即浅拷贝;而mutableCopy则是对象复制,即深拷贝。(示例1)

如果是对可变对象复制,都是深拷贝,但copy复制返回的对象是不可变的。(示例2)

【编辑推荐】

Objective-C 2.0程序设计 目录

Objective-C 2.0程序设计 译者序

Objective-C基础语法快速入门(1)

程序员转型指南 当Java遇见了Objective-C

责任编辑:zhaolei 来源: 互联网
相关推荐

2020-12-01 11:33:57

Python拷贝copy

2023-05-12 08:11:58

JavaScriptJSON克隆

2022-09-26 09:01:23

JavaScript浅拷贝深拷贝

2023-11-08 14:21:51

Python拷贝

2020-09-17 14:04:32

拷贝

2021-01-07 08:29:46

Java浅拷贝深拷贝

2021-01-08 06:15:09

深拷贝浅拷贝写时拷贝

2009-05-19 17:28:44

深拷贝浅拷贝clone()

2020-12-18 06:09:07

Java浅拷贝深拷贝

2020-07-23 15:40:54

Linux零拷贝文件

2020-07-06 15:10:05

Linux拷贝代码

2011-08-02 14:35:11

IOS应用

2009-08-27 17:33:51

Interface接口

2023-05-28 23:26:16

多模态机器学习大脑

2009-07-03 09:08:23

JSP标记学习笔记

2009-07-03 09:08:23

JSP标记学习笔记

2021-06-28 07:12:28

赋值浅拷贝深拷贝

2009-10-13 15:00:00

CCIE资料CEF技术

2009-09-14 17:10:57

LINQ模糊查询

2010-01-27 15:46:15

学习C++效率
点赞
收藏

51CTO技术栈公众号