為了解釋方便，定義兩個類：Person和MyObject，它們都繼承自NSObject。他們的關係如下:

// Person.h
@property (strong, nonatomic, nullable) MyObject *object;
// MyObjec.h
@property (copy, nonatomic) NSString *name;

對於一個OC中的物件來說，可能涉及拷貝的有三種操作：

1.retain操作：

 Person *p = [[Person alloc] init];
 Person *p1 = p;
這裡的p1預設是__strong，所以它會對p進行retain操作。retain與複製無關，只會對引用計數加1。p1和p的地址是完全一樣的：

 2015-12-23 21:24:31.893 Copy[1300:120857] p = 0x1006012c0
2015-12-23 21:24:31.894 Copy[1300:120857] p1 = 0x1006012c0
這種寫法最簡單，而且嚴格來說不是複製，但值得一提，因為在接下來的OC和Swift中，都會涉及到這樣的程式碼。

2.copy方法：

呼叫copy方法需要實現NSCopying協議，並提供copyWithZone方法：

 - (id)copyWithZone:(NSZone *)zone {
     Person *copyInstance = [[self class] allocWithZone:zone];
     copyInstance.object = self.object;
     return copyInstance;
 }
第二行程式碼就是剛剛所說的retain操作。因此，我們雖然複製了Person物件的指標，但是其內部的屬性，依然和原來物件的相同。

3.自定義拷貝方法：

我們當然可以自己定義一個拷貝方法，在複製Person物件的同時，把其中的object屬性也複製，而不是僅僅retain。
 

淺拷貝與深拷貝

標為紅色的是兩種拷貝方式的不同之處。對於左邊這種，只拷貝指標本身的拷貝方法，我們稱為淺拷貝。對於右邊那種，不僅拷貝指標自身，還拷貝指標中所有元素的拷貝方法，我們稱為深拷貝。

沒有明確的限制copy和自定義的拷貝方法要如何實現。也就是說copy方法可以用來進行深拷貝，我們也可以自定義淺拷貝的方法。這完全取決於我們自己如何實現copy方法和自定義的拷貝方法。在OC中，對於自定義的類來說，淺拷貝與深拷貝只是一種概念，並沒有明確的標註哪種方法就是淺拷貝。

注意

“深拷貝將被拷貝的物件完全複製”這種說法不完全正確。比如上圖中我們看到data

但是至於data會不會被拷貝，這取決於MyObject類如何設計，如果MyObject的copy方法只是淺拷貝，就會形成如上圖所示的情況。如果MyObject的copy方法也是深拷貝，那麼data的地址也會不同。

容器物件拷貝

在OC中，所有Foundation中的容器類，分為可變容器和不可變容器，它們的拷貝都是淺拷貝。這也就是為什麼建議自定義的物件實現淺拷貝，如果有需要才自定義深拷貝方法。因為這樣一來，所有的方法呼叫就都可以統一，不至於造成誤解。

如果我們把陣列想象成一個三層的資料結構，第一層是陣列自己的指標，第二層是存放在陣列中的指標，第三層(如果第二層是指標)則是這些指標指向的物件。那麼在複製陣列時，複製的是前兩層，第三層的物件不會被複制。如果把前兩層看做指標，第三層看做物件，那麼陣列的拷貝，無論是copy還是mutableCopy都是淺拷貝。當然，也有人把這個稱為“單層深拷貝”，這些概念性的定義都不重要，重要的是知道陣列拷貝時的原理。

這一點很好理解。首先，指標所指向的物件，也許很大，深拷貝可能佔用過多的記憶體和時間。其次，容器不知道自己儲存的物件是否實現了NSCopying協議。如果容器的拷貝預設是深拷貝，同時你在陣列中存放了Person類的物件，而Person類根本沒有實現NSCopying協議，後果是複製容器會導致程式崩潰。這是任何語言開發者都不希望看到的，所以設身處地想一下，如果是你來設計OC，也不會讓陣列深拷貝吧。

觀察下面這段程式碼，思考一下為什麼a1[0] = @0沒有影響a2:

NSMutableArray *a1 = [[NSMutableArray alloc] initWithObjects:@1, @2, nil];
NSMutableArray *a2 = [a1 mutableCopy];
a1[0] = @0;
NSLog(@"a2 = %@", a2);

/*
2015-12-23 23:11:53.711 Copy[1795:220469] a2 = (
    1,
    2
)
*/

容器物件分為可變容器與不可變容器，NSData、NSArray、NSString等都是不可變容器，以NSMutable開頭的則是它們的可變版本。下面統一用NSArray和NSMutableArray舉例說明。

因為NSMutableArray是NSArray的子類，所以NSArray物件不能強制轉換成NSMutableArray，否則在呼叫addObject方法時會崩潰。反之，NSMutableArray可以轉換成它的父類NSArray，這麼做會導致它失去可變性。

容器拷貝的難點在於可變性的變化。容器有兩種方法：copy和mutableCopy，再次強調這兩者都是淺拷貝。它們的區別在於，返回值是否是可變的。前者返回不可變容器，後者返回可變容器。

這也就是說，返回值的可變性與被拷貝物件的可變性無關，僅取決於呼叫了何種拷貝方法。比如：

NSMutableArray *mutableArray = [[NSMutableArray alloc] initWithObjects:@1, @2, nil];
NSMutableArray *array = [mutableArray copy];
[array addObject:@3];

儘管我們呼叫了mutableArray的拷貝方法，返回值也宣告為NSMutableArray，但是呼叫addObject方法時依然會導致執行時錯誤。這是由錯誤的呼叫了copy方法導致的。

呼叫一個物件的淺拷貝方法會得到一個新的物件(地址不同)，但是容器類中有一個特例：

NSArray *array1 = @[@1, @2];
NSArray *array2 = [array1 copy];
// array1和array2地址相同

字串拷貝

字串也可以被當做容器來理解。它有NSString和NSMutableString兩個版本。

於是為什麼字串屬性要定義成@property(copy, nonatomic)就很好理解了。它主要用於處理這種情況：

NSMutableString *string = @"hello";
self.propertyString = string;
[string appendString:@" world"];

Swift拷貝

結構體拷貝

陣列、字典等容器在Swift中被定義成了結構體，它們的拷貝規則和OC完全不同：

var array1 = [1,2,3]
var array2 = array1

array1[0] = 0
print(array2) // 輸出結果：[1, 2, 3]

物件拷貝

和OC中指標賦值類似，物件的直接賦值操作與拷貝無關：

class Person {
    var name: String;
    init(name:String) {
        self.name = name
    }
}

let person1 = Person(name: "zxy")
let person2 = person1
person1.name = "new name"

print(person2.name) //結果是“new name”

class Person : NSObject, NSCopying {
    var name: String;
    init(name:String) {
        self.name = name
    }

    func copyWithZone(zone: NSZone) -> AnyObject {
        return Person(name: self.name)
    }
}

“面向介面程式設計”的原則告訴我們，我們應該讓Person實現某個介面，而不是繼承自某個子類：

protocol Copyable {
    func copy() -> Copyable
}

class Person : Copyable {
    var name: String;
    init(name:String) {
        self.name = name
    }

    func copy() -> Copyable {
        return Person(name: self.name)
    }
}

let person1 = Person(name: "zxy")
let person2 = person1.copy() as! Person

總結

在OC中，淺拷貝通常由NSCopying協議的copyWithZone方法實現，深拷貝需要自定義方法。直接複製意味著retain而不是拷貝。

在Swift中，值型別直接用等號賦值意味著淺拷貝，引用型別的拷貝可以通過實現自定義的Copyable協議或OC的NSCopying協議完成。

在OC中，我們需要容器的可變性，而Swift在這一點做的要比OC好得多。它的可變性非常簡單，完全通過let和var控制，這也是Swift相比於OC的一個優點吧，畢竟高階的語言應該儘可能封裝底層實現。

簡書部落格地址