在初學 iOS 的時候，可能會被灌輸這麼一個常識，切記 NSString 的 property 的修飾變量要寫作 copy ，而不是 strong，那麼這是為什麼？

經典面試題：為什麼 NSString 類型成員變量的修飾屬性用 copy 而不是 strong (或 retain ) ？

review Copy Operation

Test 1

先來模擬一個程序設計錯誤的場景。有一個叫做 Person 的 Class，其中它擁有一個 NSString 類型的 s_name 屬性（代表 name 是 strong），我們想給一個對象的 s_name 賦值，並且之前的賦值變量還想重復使用到其他場景。所以，我們在引入這個 Class 的 ViewController 進行如下操作：

- (void)test1 {
    self.one = [[Person alloc] init];
    NSMutableString *name = [NSMutableString stringWithFormat:@"iOS"];
    self.one.s_name = name;
    NSLog(@"%@", self.one.s_name);
    [name appendString:@" Source Probe"];
    NSLog(@"%@", self.one.s_name);
}

如果在 Person 這個 Class 中，我們的 s_name 的修飾屬性是 strong 的話，會看到如下輸出結果。

2016-08-12 05:51:21.262 TestCopy[64714:20449045] iOS
2016-08-12 05:51:21.262 TestCopy[64714:20449045] iOS Source Probe

可是，我們操作的僅僅是對 s_name 那個變量，為什麼連屬性當中的 s_name 也會被改變？對這段代碼稍做修改，重新測試。

Test 2

- (void)test2 {
    self.one = [[Person alloc] init];
    NSString *name = [NSMutableString stringWithFormat:@"iOS"];
    self.one.s_name = name;
    NSLog(@"%@", self.one.s_name);
    name = @"iOS Source Probe";
    NSLog(@"%@", self.one.s_name);
}

這一次我們看到了輸出結果是正常的：

2016-08-12 05:56:57.162 TestCopy[64842:20459179] iOS
2016-08-12 05:56:57.162 TestCopy[64842:20459179] iOS

Test 3

再來做第三個實驗，我們換用 copy 類型的成員 c_name，來替換實驗1中的 s_name ，查看一下輸出結果。

最後發現輸出結果依舊是我們所需要的。

- (void)test3 {
    self.one = [[Person alloc] init];
    NSMutableString *name = [NSMutableString stringWithFormat:@"iOS"];
    self.one.c_name = name;
    NSLog(@"%@", self.one.c_name);
    [name appendString:@" Source Probe"];
    NSLog(@"%@", self.one.c_name);
}

2016-08-12 06:03:40.226 TestCopy[64922:20479646] iOS 
2016-08-12 06:03:40.227 TestCopy[64922:20479646] iOS

做過如上三個實驗，或許你會知道對 property 使用 copy 修飾屬性的原因了。也就是在一個特定場景下：當我們通過一個 NSMutableString 對 NSString 變量進行賦值，如果 NSString 的 property 是 strong 類型的時候，就會隨著 NSMutableString 類型的變量一起變化。

這個猜測是正確的。在 stackoverflow 上也對這個場景進行單獨的描述。可是原因是什麼？繼續做下面的實驗：

Test 4

- (void)test4 {
    NSMutableString *str = [NSMutableString stringWithFormat:@"iOS"];
    NSLog(@"%p", str);
    NSString *str_a = str;
    NSLog(@"%p", str_a);
    NSString *str_b = [str copy];
    NSLog(@"%p", str_b);
}

輸出地址後，我們發現以下結果：

2016-08-12 06:15:45.169 TestCopy[65230:20515110] 0x7faf28429e70
2016-08-12 06:15:45.170 TestCopy[65230:20515110] 0x7faf28429e70
2016-08-12 06:15:45.170 TestCopy[65230:20515110] 0xa00000000534f693

發現當令 NSString 對象指針指向一個 NSMutableString 的時候，則會對一個對象進行深復制。這也就是我們一直所說的在一個 Class 的成員是 NSString 類型的時候，修飾屬性應該使用 copy ，其實就是在使用 mutable 對象進行賦值的時候，防止 mutable 對象的改變從而影響成員變量。從 MRC 的角度來看待修飾屬性，若一個屬性的關鍵字為 retain （可等同於 strong ），則在進行指針的指向修改時，如上面的self.one.name = str，其實是執行了self.one.name = [str retain]，而 copy 類型的屬性則會執行self.one.name = [str copy]。

而在 Test 2 中，我們的實驗是將一個 NSString 對象指向另外一個 NSString 對象，那麼如果前者是 copy 的成員，還會進行深復制嗎？進行下面的 Test 5，我們令 c_name 的修飾變量為 copy。

Test 5

- (void)test5 {
    self.one = [[Person alloc] init];
    NSString *name = [NSMutableString stringWithFormat:@"iOS"];
    self.one.c_name = name;
    NSLog(@"%@", self.one.c_name);
    name = @"iOS Source Probe";
    NSLog(@"%@", self.one.c_name);
    NSString *str = [NSString stringWithFormat:@"iOS"];
    NSLog(@"%p", str);
    NSString *str_a = str;
    NSLog(@"%p", str_a);
    NSString *str_b = [str copy];
    NSLog(@"%p", str_b);
}

發現結果符合猜測：

2016-08-12 08:09:28.125 TestCopy[66402:20671038] iOS
2016-08-12 08:09:28.126 TestCopy[66402:20671038] iOS
2016-08-12 08:09:28.126 TestCopy[66402:20671038] 0xa00000000534f693
2016-08-12 08:09:28.126 TestCopy[66402:20671038] 0xa00000000534f693
2016-08-12 08:09:28.126 TestCopy[66402:20671038] 0xa00000000534f693

從一個 NSString 進行 copy 後賦值，copy 方法仍舊是淺拷貝。這個效果就等同於str_b = [str retain]，在 ARC 中即 str_b = str。

那麼，如何在這種情況下，讓str_b指向一個str的深拷貝呢，答案就是str_b = [str mutableCopy]。這也就是 copy 和 mutableCopy 的區別。

copy & mutableCopy

下面我們開始對 copy 和 mutableCopy 原理進行分析。以下也是我的源碼學習筆記。

在opensource.apple.com的git倉庫中的Runtime源碼中有NSObject.mm這個文件，其中有如下方法是關於 copy 的：

- (id)copy {
    return [(id)self copyWithZone:nil];
}
- (id)mutableCopy {
    return [(id)self mutableCopyWithZone:nil];
}

發現copy和mutableCopy兩個方法只是簡單調用了copyWithZone:和mutableCopyWithZone:兩個方法。所以有了以下猜想：對於 NSString 和 NSMutableString，Foundation 框架已經為我們實現了 copyWithZone 和 mutableCopyWithZone 的源碼。我在searchcode.com找到了 Hack 版的 NSString 和 NSMutableString 的 Source Code。

在NSString.m中，看到了以下關於 copy 的方法。

- (id)copyWithZone:(NSZone *)zone {
    if (NSStringClass == Nil)
        NSStringClass = [NSString class];
    return RETAIN(self);
}
- (id)mutableCopyWithZone:(NSZone*)zone {
    return [[NSMutableString allocWithZone:zone] initWithString:self];
}

而在 NSMutableString.m 中只發現了copyWithZone:和copy:方法，並且它調用了父類的全能初始化方法（designated initializer），所以構造出來的對象是由 NSString 持有的：

-(id)copy {
    return [[NSString alloc] initWithString:self];
}
-(id)copyWithZone:(NSZone*)zone {
    return [[NSString allocWithZone:zone] initWithString:self];
}

也就是說， NSMutableString 進行 copy 的對象從源碼上看也會變成深復制方法。我們做下試驗。

Test 6

- (void)test6 {
    NSMutableString *str = [NSMutableString stringWithFormat:@"iOS"];
    NSLog(@"%p", str);
    NSMutableString *str2 = [str copy];
    NSLog(@"%p", str2);
}

2016-08-12 15:12:12.845 TestCopy[73658:21549553] 0x7f96f8410e10 
2016-08-12 15:12:12.846 TestCopy[73658:21549553] 0xa00000000534f693

輸出結果如我們所預料的，同樣是 NSMutableString 之間的指針傳遞，即使類型相同，使用了該類型下的 copy 方法，也會變成深復制，因為返回的對象如源碼所示，調用了 NSString 的全能初始化方法，並且由一個新的 NSString 持有。那麼在 NSMutableString 中使用mutableCopy，可以做到單純的 retain 操作嗎。答案也是否定的，同樣是源碼中寫道，在源碼中並沒有重寫mutableCopy方法，也沒有實現mutableCopyWithZone:方法，所以會調用父類的mutableCopyWithZone。而在父類中 mutableCopyWithZone:方法中調用了 NSMutableString 的全局初始化方法，所以依舊是深復制。

以上原則試用於大多數 Foundation 框架中的常用類，如 NSArray 、 NSDictionary 等等。

關於自定義 Class 的 Copy 方法

對於以上所有試驗，我們可以總結一個中關系：

由此，我們可以總結一下。其實 Copy 對應的也就是類似於 immutableCopy 這種感覺，因為通過 copy 出的對象總是不可變的。所以對於一個 Class 中的 mutableCopy 和 copy 的方法命名而言，其實是否有 mutable ，是針對於返回值而言的。在 Foundation Framework 中，把拷貝方法稱為 copy 而非 immutableCopy 的原因在於，NSCopying 這個基礎協議不僅設計給那些具有可變和不可變版本的類來用，而且還要供其他一些沒有“可變”和“不可變”之分的類來用。

所以在實現自定義 Class 的 Copy 方法適合，我們需要確定一個問題，應該執行深復制還是淺復制。然後在去實現對應的 copyWithZone: 和 mutableCopyWithZone: 兩個方法。這裡我不再多論，可以查看 Effective Objective-C 2.0 52 Specific Ways to Improve Your iOS and OS X Programes 的 Tips 22 。

對於很多博文的一些疑問

在很多關於討論自定義 Class 中的 Copy 方法，都會強調一句：我們一定要遵循 NSCopying 或 NSMutableCopying 這兩個協議，並且在實例代碼中也顯式寫出了自定義的 Class 是遵循這兩個協議的，如下：

@interface XXObject: NSObject 
@end

但是如果我們不顯式的寫出，我們發現不但沒有 crash ，而且結果也是完全一樣的。而在 Objective-C copy那些事兒 此文中，作者寫道：

正確的做法是讓自定義類遵循NSCopying協議（NSObject並未遵循該協議）

我的猜想是，某次蘋果所用的 Foundation 框架升級，使得 NSObject 開始遵循 NSCopying 方法，但是沒有去實現（這就好比 c++ 中的 virtual 虛函數）。這裡有待考證，如果有朋友知道，歡迎補充這一部分知識，請大家多多指教。