當前位置：首頁 >

ObjectiveC 深浅拷贝学习

發布時間：2023/12/4 64 豆豆

生活随笔收集整理的這篇文章主要介紹了 ObjectiveC 深浅拷贝学习小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

（轉自 http://woshao.com/article/f91898b24a1211e097d3000c2959fd2a/）

在ObjC中，什么是深淺拷貝？
深淺拷貝分別指深拷貝和淺拷貝，即mutableCopy和copy方法。
copy復制一個不可變對象，而mutableCopy復制一個mutable可變對象。

什么時候用到深淺拷貝？下面舉幾個例子說明。

非容器類對象

如NSString，NSNumber等一類對象
示例1：

1
2
3
4
5

// 非容器類對象
? ??NSString?*str?=?@"origin string";
? ??NSString?*strCopy?=?[str copy];
? ??NSMutableString?*mstrCopy?=?[str mutableCopy];
? ??[mstrCopy appendString:@"??"];

查看內存可以發現，str和strCopy指向的是同一塊內存區域，我們稱之為弱引用（weak reference）。而mstrCopy是真正的復制，系統為其分配了新內存空間，保存從str復制過來的字符串值。從最后一行代碼中修改這些值而不影響str和strCopy中可證明。

示例2：

1
2
3
4
5
6
7

NSMutableString?*mstr?=?[NSMutableString?stringWithString:@"origin"];
? ??NSString?*strCopy?=?[mstr copy];
? ??NSMutableString?*mstrCopy?=?[mstr copy];
? ??NSMutableString?*mstrMCopy?=?[mstr mutableCopy];
? ??//[mstrCopy appendString:@"1111"]; ?//error
? ??[mstr appendString:@"222"];
? ??[mstrMCopy appendString:@"333"];

以上四個對象所分配的內存都是不一樣的。而且對于mstrCopy，它所指向的其實是一個imutable對象，是不可改變的，所以會出錯。這點要注意，好好理解。

小結：
對于非容器類對象，有：

如果對一個不可變對象復制，copy是指針復制，即淺拷貝；而mutableCopy則是對象復制，即深拷貝。（示例1）
如果是對可變對象復制，都是深拷貝，但copy復制返回的對象是不可變的。（示例2）

容器類對象深淺復制

比如NSArray，NSDictionary等。對于容器類本身，上面討論的結論也適用的，下面探討的是復制后容器內對象的變化。

示例3

1
2
3
4
5
6
7
8
9
10
11
12

/* copy返回不可變對象，mutablecopy返回可變對象 */
? ??
? ??NSArray?*array1 ? ??=?[NSArray?arrayWithObjects:@"a",@"b",@"c",nil];
? ??NSArray?*arrayCopy1?=?[array1 copy];
? ??//arrayCopy1是和array同一個NSArray對象（指向相同的對象），包括array里面的元素也是指向相同的指針
? ? NSLog(@"array1 retain count: %d",[array1 retainCount]);
? ? NSLog(@"array1 retain count: %d",[arrayCopy1 retainCount]);
? ??
? ??NSMutableArray?*mArrayCopy1?=?[array1 mutableCopy];
? ??//mArrayCopy1是array1的可變副本，指向的對象和array1不同，但是其中的元素和array1中的元素指向的還是同一個對象。mArrayCopy1還可以修改自己的對象
? ??[mArrayCopy1 addObject:@"de"];
? ??[mArrayCopy1 removeObjectAtIndex:0];

array1和arrayCopy1是指針復制，而mArrayCopy1是對象復制，符合前面示例1討論的結論。mArrayCopy1可以改變其內的元素：刪除或添加。但容器內的元素內容都是淺拷貝。

示例4

1
2
3
4
5
6
7
8
9
10
11
12
13

NSArray?*mArray1?=?[NSArray?arrayWithObjects:[NSMutableString?stringWithString:@"a"],@"b",@"c",nil];
? ? NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);
? ??NSArray?*mArrayCopy2?=?[mArray1 copy];
? ? NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);
? ??// mArray1和mArrayCopy2指向同一對象，retain值+1。
? ??
? ??NSMutableArray?*mArrayMCopy1?=?[mArray1 mutableCopy];
? ? NSLog(@"mArray1 retain count: %d",[mArray1 retainCount]);
? ??//mArrayCopy2和mArray1指向的是不一樣的對象，但是其中的元素都是一樣的對象——同一個指針

? ??NSMutableString?*testString?=?[mArray1 objectAtIndex:0];
? ??//testString = @"1a1";//這樣會改變testString的指針，其實是將@“1a1”臨時對象賦給了testString
? ??[testString appendString:@" tail"];//這樣以上三個數組的首元素都被改變了

由此可見，對于容器而言，其元素對象始終是指針復制。如果需要元素對象也是對象復制，就需要實現深拷貝。http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Collections/Articles/Copying.html

示例5

1
2
3
4

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]盡管是指向同一塊內存，但是我們沒有辦法對其進行修改——因為它是不可改變的。所以指針復制已經足夠。所以這并不是完全意義上的深拷貝。

自己實現深拷貝的方法

NSDictionaryMutableDeepCopy.h

1
2
3
4
5
6
7
8

#import <foundation /Foundation.h>

@interface?NSDictionary(MutableDeepCopy)

-?(NSMutableDictionary?*)mutableDeepCopy;

@end
</foundation>

NSDictionaryMutableDeepCopy.m

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

#import "NSDictionaryMutableDeepCopy.h"

@implementation?NSDictionary(MutableDeepCopy)

-?(NSMutableDictionary?*)mutableDeepCopy?{
? ??NSMutableDictionary?*ret?=?[[NSMutableDictionary?alloc]
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? initWithCapacity:[self count]];
? ??NSArray?*keys?=?[self allKeys];
? ??for?(id?key?in?keys)?{
? ? ? ??id?oneValue?=?[self valueForKey:key];
? ? ? ??id?oneCopy?=?nil;
? ? ? ??
? ? ? ??if?([oneValue respondsToSelector:@selector(mutableDeepCopy)])?{
? ? ? ? ? ? oneCopy?=?[oneValue mutableDeepCopy];
? ? ? ??}
? ? ? ??else?if?([oneValue respondsToSelector:@selector(mutableCopy)])?{
? ? ? ? ? ? oneCopy?=?[oneValue mutableCopy];
? ? ? ??}
? ? ? ??if?(oneCopy?==?nil)?{
? ? ? ? ? ? oneCopy?=?[oneValue copy];
? ? ? ??}
? ? ? ??[ret setValue:oneCopy forKey:key];
? ??}
? ??
? ??return?ret;
}

@end

使用類別方法來實現。

自定義對象

如果是我們定義的對象，那么我們自己要實現NSCopying,NSMutableCopying這樣就能調用copy和mutablecopy了。舉個例子：

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
5

@interface?MyObj?:?NSObject<nscopying ,NSMutableCopying>
{
? ? ? ? ?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;
}
@end
</nscopying

本文參考了on my way的《ios 深淺拷貝學習》

文章來源：http://donbe.blog.163.com/blog/static/13804802120103272343790/

原來不是所有的對象都支持 copy
只有遵守NSCopying 協議的類才可以發送copy消息
只有遵守 NSMutableCopying 協議的類才可以發送mutableCopy消息

假如發送了一個沒有遵守上訴兩協議而發送 copy或者 mutableCopy,那么就會發生異常

默認 nsobject沒有遵守這兩個協議
但是 copy和mutableCopy這兩個方法是nsobject定義的

如果想自定義一下copy 那么就必須遵守NSCopying,并且實現 copyWithZone: 方法
如果想自定義一下mutableCopy 那么就必須遵守NSMutableCopying,并且實現 mutableCopyWithZone: 方法

看了一下幾個遵守 NSCopying協議的基本上是一些基礎核心類
比如 NSString NSNumber

copy以后,就是返回一個新的類, 你要負責釋放掉,原先被拷貝的retaincount沒有+1 所以,不需要負責釋放

copy和mutableCopy 就是copy返回后的是不能修改的對象, mutableCopy返回后是可以修改的對象

下面是實現一個copyWithZone的例子
@interface BankAccount: NSObject <NSCopying>
{
double accountBalance;
long accountNumber;
}
-(void) setAccount: (long) y andBalance: (double) x;
-(double) getAccountBalance;
-(long) getAccountNumber;
-(void) setAccountBalance: (double) x;
-(void) setAccountNumber: (long) y;
-(void) displayAccountInfo;
-(id) copyWithZone: (NSZone *) zone;
@end

-(id) copyWithZone: (NSZone *) zone
{
BankAccount *accountCopy = [[BankAccount allocWithZone: zone] init];

[accountCopy setAccount: accountNumber andBalance: accountBalance];
return accountCopy;
}

深度拷貝和淺拷貝
上面的方法是淺拷貝,意思就是,只是重新分配了BankAccount類的內存,并沒有對BankAccount的屬性重新分配內存
兩個BankAccount的屬性都是指向同一個地方的. 修改了其中一個BankAccount屬性,那么另外一個BankAccount屬性
也會一起發生變化?

深度拷貝
深度拷貝這里用到一個存檔功能,先把原先的存檔(其實就是序列化對象,然后存到一個文件,等下可以反序列化出來賦值給另外一個對象),然后存到另外的而一個對象中
NSKeyedArchiver 序列化類
NSKeyedUnarchiver 反序列化類

NSArray *myArray1;
NSArray *myArray2;
NSMutableString *tmpStr;
NSMutableString *string1;
NSMutableString *string2;
NSMutableString *string3;
NSData *buffer;

string1 = [NSMutableString stringWithString: @"Red"];
string2 = [NSMutableString stringWithString: @"Green"];
string3 = [NSMutableString stringWithString: @"Blue"];

myArray1 = [NSMutableArray arrayWithObjects: string1, string2, string3, nil];

buffer = [NSKeyedArchiver archivedDataWithRootObject: myArray1];
myArray2 = [NSKeyedUnarchiver unarchiveObjectWithData: buffer];

tmpStr = [myArray1 objectAtIndex: 0];

[tmpStr setString: @"Yellow"];

NSLog (@"First element of myArray1 = %@", [myArray1 objectAtIndex: 0]);
NSLog (@"First element of myArray2 = %@", [myArray2 objectAtIndex: 0]);

cocoa 的屬性也有3種
protected - Access is allowed on

ly by methods of the class and any subclasses. 默認是這個
private - Access is restricted to methods of the class. Access is not available to subclasses.?
public - Direct access available to methods of the class, subclasses and code in other module files and classes.
public的變量可以用 -> 操作符訪問

參考地址:http://www.techotopia.com/index.php/Copying_Objects_in_Objective-C
http://wenku.baidu.com/view/12d6592fb4daa58da0114af0.html
http://www.techotopia.com/index.php/Objective-C_-_Data_Encapsulation,_Synthesized_Accessors_and_Dot_Notation

關于訪問器的詳細文檔
http://cocoacast.com/?q=node/103

轉載于:https://www.cnblogs.com/pengyingh/articles/2352908.html

總結

以上是生活随笔為你收集整理的ObjectiveC 深浅拷贝学习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： SQL SERVER2000存储过程调试
下一篇： port wifi to ICS(4.0