您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

《招聘一個靠譜的 iOS》面試題參考答案(上):風格規範、記憶體管理與 Runtime

編輯:iOS 開發基礎

本文為《招聘一個靠譜的 iOS》面試題的參考解答(上篇)。

說明:面試題出自微博 @我就叫Sunny怎麼了的博文《招聘一個靠譜的 iOS》,共 55 題,除第一題為風格糾錯題外,其餘 54 題皆為簡答題。

原文提供了高品質的題目但未附解答,因此我嘗試整理了一份答案,分兩篇發布。這是上篇,下篇將發布於此處,並會補完剩餘問題、進行勘誤,歡迎指正文中錯誤。答案未經出題者校對,如有疏漏請向微博 @iOS程序犭袁 指正。

出題者簡介:孫源(sunnyxx),任職於百度,負責百度知道 iOS 客戶端開發。他喜歡對技術刨根問底、歸納最佳實踐,熱愛分享與開源,並維護名為 forkingdog 的開源小組。

1. 風格糾錯題

修改方式有很多種,以下提供一種示範:

下面把修改點分成兩部分說明:優化部分與硬傷部分。硬傷部分技術含量不高,為了節省時間放到後面講,可以先看優化部分。

優化部分

1)枚舉建議使用 NS_ENUM 與 NS_OPTIONS 巨集定義,參見官方文件 Adopting Modern Objective-C:

//定義一個枚舉 typedef NS_ENUM(NSInteger, CYLSex) {     CYLSexMan,     CYLSexWoman };

2)age 屬性的型別:應避免直接使用基本型別,改用 Foundation 型別,對應關係如下:

  int -> NSInteger   unsigned -> NSUInteger   float -> CGFloat   動畫時間 -> NSTimeInterval

同時考慮到年齡不會為負,應使用 NSUInteger 而非 int。這樣做是基於 64 位元適配的考量,細節可參考出題者的博文《64-bit Tips》。

3)前綴規範:專案龐大到需要拆分模組時,可在類別與 typedef 巨集命名上加前綴以避免衝突。

4)doLogIn 方法不該寫在這個類別裡:先不糾結 LogIn 的命名是否恰當(推測是 login 的意思),登入屬於業務邏輯。觀察類名 UserModel 與屬性命名方式,應該是採用 MVC 而非 MVVM,而 MVC 中業務邏輯不應寫在 Model 裡。(若是 MVVM,撇開命名規範不談,UserModel 這個類可能對應的是使用者註冊頁面;若有特殊業務需求,例如 login 實際對應的是「註冊並登入」的按鈕,出現 login 方法也可能是合理的。)

5)doLogIn 命名多餘:加了不必要的動詞前綴。請記住:如果方法表示讓物件執行一個動作,用動詞開頭命名即可,不要加上 do、does 這類冗詞,動詞本身就足夠清楚。

6)不要用 with 串接參數:-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age; 中的 withAge: 應改為 age:,age: 已足以說明參數用途。也不建議用 andAge:——通常即使有類似 withA:withB: 的命名需求,也多寫成 withA:andB:,用來表示方法執行了兩個相對獨立的操作(從設計角度看,這種情況其實也該考慮拆成兩個方法),它並非用來闡明「有多個參數」:

//錯誤,不要使用"and"來連接參數 - (int)runModalForDirectory:(NSString *)path andFile:(NSString *)name andTypes:(NSArray *)fileTypes; //錯誤,不要使用"and"來闡明有多個參數 - (instancetype)initWithName:(CGFloat)width andAge:(CGFloat)height; //正確,使用"and"來表示兩個相對獨立的操作 - (BOOL)openFile:(NSString *)fullPath withApplication:(NSString *)appName andDeactivate:(BOOL)flag;

7)字串屬性應聲明為 copy:因為字串的值可能變動,內存管理語義需標明 copy。原因在後文有詳細論述。

8)性別屬性如何初始化?該類別只提供了一個初始化方法來設定姓名與年齡,那性別呢?

Objective-C 有 designated(指定)與 secondary(次要)初始化方法的概念。designated 初始化方法提供所有參數;secondary 初始化方法則透過提供一個或多個預設參數,去呼叫 designated 初始化方法。舉例:

  // .m文件   // https://weibo.com/luohanchenyilong/   // https://github.com/ChenYilong   //   @implementation CYLUser   - (instancetype)initWithName:(NSString *)name                              age:(int)age                           sex:(CYLSex)sex {       if(self = [super init]) {             _name = [name copy];             _age = age;             _sex = sex;       }       return self;   }   - (instancetype)initWithName:(NSString *)name                              age:(int)age {       return [self initWithName:name age:age sex:nil];   }   @end

其中 initWithName:age:sex: 是 designated 初始化方法,另一個是 secondary 初始化方法,因為它僅是轉呼叫前者的實作。

由於出題者未提供 .m 檔,有兩種可能:一是原本只打算設計一個 designated 初始化方法,但漏掉了性別屬性,那麼就採用上面第一種改法;二是不打算在初始化時設定性別,預計後期再改,那麼應該把性別屬性設為 readwrite,改法如下:

在 .h 中公開 designated 初始化方法,是為了方便子類化(想深入了解可參考《禪與 Objective-C 編程藝術》中文版)。

9)搭配便捷構造方法:依介面設計慣例,設計了初始化方法就應搭配一個便捷構造方法,其回傳值建議為 instancetype。為保持一致,init 方法與便捷構造方法的回傳型別最好都用 instancetype。

10)屬性應盡量設為唯讀:若採用第一種改法,既然已透過初始化方法設定好姓名、年齡、性別,那對應的 @property 就應該盡量使用不可變物件,三個屬性都設為 readonly——初始化完成後便不能再改。本例中仍需標明內存管理語義,因此可改為:

@property (nonatomic, copy, readonly) NSString *name; @property (nonatomic, assign, readonly) NSUInter age; @property (nonatomic, assign, readonly) CYLSex sex;

由於是唯讀屬性,編譯器不會為它們建立 setter。即便如此,還是要標明這些屬性的語義,用以表明初始化方法設定這些值時所採用的方式。若不標明,呼叫者就不知道初始化方法會複製這些屬性,可能在呼叫前自行先複製一次,多餘且低效。

11)initUserModelWithUserName 改為 initWithName 更簡潔,且語意同樣清晰。

12)UserModel 改為 User 更簡潔,也足夠清楚。

13)UserSex 改為 Sex 更簡潔,也足夠清楚。

硬傷部分

1)在 - 與 (void) 之間應有一個空格。

2)enum 中駝峰命名與底線命名混用。枚舉類型的命名規則與函數相同:使用駝峰命名法,勿用底線。

3)enum 左括號前加一個空格,或將左括號換到下一行。

4)enum 右括號後加一個空格。

5)UserModel :NSObject 應為 UserModel : NSObject,冒號右側少了一個空格。

6)@interface 與 @property 聲明之間應空一行。

7)兩個方法定義之間不需要空行;若為區分功能也可空一行,但範例中空了兩行。

8)-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age; 中,方法名與參數之間多了空格,且 - 與 (id) 之間少了空格。

9)同一行中,(NSString*)name 前多了空格。

10)同一行中,(NSString*)name 應為 (NSString *)name,少了空格。

11)doLogIn 命名不清晰,推測是 login 的手誤。

12)第二個 @property 中 assign 與 nonatomic 順序應對調。

2. 什麼時候使用 weak?與 assign 有何不同?

使用時機

1)在 ARC 中,可能出現循環參照時,通常讓其中一端使用 weak 來解決,例如 delegate 代理屬性。

2)自身已經對它有一次強參照,沒有必要再強參照一次,此時也會用 weak。自訂的 IBOutlet 控件屬性一般也使用 weak(當然也可以用 strong,下文有論述)。

差異

1)weak 表明該屬性定義了一種「非擁有關係」(nonowning relationship)。設定新值時,setter 既不保留新值也不釋放舊值。這點與 assign 類似,但差別在於:當屬性所指的物件被銷毀時,weak 屬性會自動清空為 nil;而 assign 的 setter 只做針對純量類型(例如 CGFloat、NSInteger)的簡單賦值。

2)assign 可以用於非 Objective-C 物件,weak 則必須用於 Objective-C 物件。

3. 怎麼用 copy 關鍵字?

用途

1)NSString、NSArray、NSDictionary 等經常使用 copy,是因為它們都有對應的可變類型:NSMutableString、NSMutableArray、NSMutableDictionary。

2)block 也常用 copy,原因見官方文件 Objects Use Properties to Keep Track of Blocks。

block 使用 copy 是 MRC 時代留下的傳統:MRC 中方法內部的 block 位於堆疊區,用 copy 可以把它複製到堆區。在 ARC 下寫不寫都可以——對 block 而言 copy 與 strong 效果相同,但寫上 copy 無傷大雅,還能提醒自己編譯器自動執行了複製。

補充說明:copy 表達的擁有關係與 strong 類似,但 setter 不保留新值,而是將其複製一份。當屬性型別為 NSString 時,常用此特質保護封裝性,因為傳入的新值可能指向一個 NSMutableString 實例——它是 NSString 的子類,可修改內容。若不複製,設定完屬性後字串值可能在物件不知情的情況下被改掉。因此要複製一份不可變字串,確保值不會無意間變動。只要實作屬性所用的物件是可變的,就應該在設定新值時複製一份。

用 @property 聲明 NSString、NSArray、NSDictionary 時常用 copy,是因為它們有對應的可變類型,彼此之間可能發生賦值操作;為確保物件內的值不被外部改動,應在設定新值時複製。

4. @property (copy) NSMutableArray *array; 會有什麼問題?

兩個問題:

1、在增刪改陣列元素時,程式會因為找不到對應方法而崩潰——因為 copy 複製出來的是不可變的 NSArray 物件。

2、使用 atomic 屬性會嚴重影響效能。

第二點的原因:該屬性使用了同步鎖,會在編譯時產生額外套路以協助撰寫多執行緒程式,帶來效能負擔。宣告 nonatomic 可以省下這些雖小但不必要的開銷。

預設情況下,編譯器合成的方法會透過鎖定機制確保原子性(atomicity)。若屬性具備 nonatomic 特質,則不使用同步鎖。注意,並沒有一個叫 atomic 的特質關鍵字——不具備 nonatomic 的屬性就是「原子的」。

在 iOS 開發中你會發現,幾乎所有屬性都宣告為 nonatomic。一般並不要求屬性必須是原子的,因為這並不能保證執行緒安全;要實現執行緒安全,需要更深層的鎖定機制。舉例來說,若一個執行緒連續多次讀取某屬性值的過程中,另有執行緒在改寫它,那麼即使宣告為 atomic,仍可能讀到不同的值。因此 iOS 開發時一般都使用 nonatomic。而在開發 Mac OS X 程式時,使用 atomic 通常不會遇到效能瓶頸。

5. 如何讓自己的類別支援 copy?如何重寫帶 copy 的 setter?

若想讓自訂物件具備複製能力,需實作 NSCopying 協議。若自訂物件分為可變與不可變版本,則需同時實作 NSCopying 與 NSMutableCopying 協議。

步驟:

1)宣告該類別遵循 NSCopying 協議

2)實作協議中唯一的方法:

- (id)copyWithZone: (NSZone*) zone

注意:一提到讓類別支援 copy,我們直覺想覆寫 copy 方法,但真正需要實作的其實是 copyWithZone:。

以第一題的程式碼為例:

然後實作協議方法:

但實務專案不會這麼單純。假設 CYLUser 裡還有一個陣列,用來存放與其他 CYLUser 物件建立或解除朋友關係的資料,那麼複製時就得把這個陣列也一併處理。所需程式碼如下:

// .m 檔

以上做法能滿足基本需求,但有缺陷:若需要深層複製,可考慮新增一個專門執行深拷貝的方法。

【註:深淺拷貝的概念見下文「用 @property 聲明的 NSString 經常使用 copy 關鍵字,為什麼?」】

範例中存放朋友物件的 set 是用 copyWithZone: 拷貝的,這種淺拷貝不會逐一複製 set 中的元素。若需要深拷貝,可以這樣寫一個專用的方法:

- (id)deepCopy {     CYLUser *copy = [[[self copy] allocWithZone:zone]                           initWithName:_name                                       age:_age                                                                        sex:sex];     copy->_friends = [[NSMutableSet alloc] initWithSet:_friends                                                        copyItems:YES];     return copy; }

至於如何重寫帶 copy 的 setter,若撇開本例泛談,寫法如下:

- (void)setName:(NSString *)name {     _name = [name copy]; }

但就上文的程式碼而言,我們不需要也不能重寫 name 的 setter:name 是唯讀屬性,編譯器不會為它建立 setter,透過初始化方法設定好之後便不能再改。(本例之所以仍標明 copy 語義,是為了讓呼叫者知道初始化方法會複製這些屬性,避免他們重複複製。)

那如何確保 name 被複製?在初始化方法中處理即可:

- (instancetype)initWithName:(NSString *)name                               age:(int)age                               sex:(CYLSex)sex {       if(self = [super init]) {             _name = [name copy];             _age = age;             _sex = sex;             _friends = [[NSMutableSet alloc] init];       }       return self; }

6. @property 的本質是什麼?ivar、getter、setter 如何生成並加入類別?

本質

@property = ivar + getter + setter。

「屬性」有兩大概念:ivar(實例變數)與存取方法(access method = getter + setter)。

屬性作為 Objective-C 的一項特性,主要作用在於封裝物件中的資料。Objective-C 物件通常把所需資料存為各種實例變數,而實例變數一般透過存取方法存取:getter 讀取值,setter 寫入值。這個概念早已定型,並在 Objective-C 2.0 中透過「屬性」成為語言的一部分。正因為存取方法有著嚴格的命名規範,Objective-C 才能依名稱自動建立存取方法。因此也可以說:

@property = getter + setter;

例如這個類別:

@interface Person : NSObject  @property NSString *firstName;  @property NSString *lastName;  @end

等效於:

@interface Person : NSObject  - (NSString *)firstName;  - (void)setFirstName:(NSString *)firstName;  - (NSString *)lastName;  - (void)setLastName:(NSString *)lastName;  @end

自動合成(autosynthesis)

完成屬性定義後,編譯器會自動撰寫存取屬性所需的方法,這個過程稱為「自動合成」。它由編譯器在編譯期執行,所以編輯器裡看不到這些合成方法的原始碼。除了產生 getter、setter 之外,編譯器還會自動在類別中加入適當型別的實例變數,並在屬性名前加底線作為實例變數名。上例中會產生 _firstName 與 _lastName 兩個實例變數。也可以在實作檔中透過 @synthesize 指定實例變數名稱:

@implementation Person  @synthesize firstName = _myFirstName;  @synthesize lastName = myLastName;  @end

我曾經反編譯相關程式碼以確認屬性的實作方式,大致會產生五樣東西:

1)OBJC_IVAR_$類名$屬性名稱:該屬性的「位移量」(offset),這個值是硬編碼的,表示該變數距離存放物件所在的記憶體起始位址有多遠。

2)setter 與 getter 方法對應的實作函數

3)ivar_list:成員變數列表

4)method_list:方法列表

5)prop_list:屬性列表

也就是說,每次新增一個屬性,系統都會在 ivar_list 加入成員變數描述、在 method_list 加入 setter 與 getter 的描述、在屬性列表加入屬性描述,然後計算該屬性在物件中的位移量,並產生 setter 與 getter 的實作:setter 從位移量位置開始賦值,getter 從該位置取值。為了讀取正確的位元組數,系統還會對位移量的指標型別做強制轉型。

7. @protocol 與 category 中如何使用 @property

1)在 protocol 中使用 property 只會產生 setter 與 getter 的方法宣告。我們使用屬性的目的,是希望遵循該協議的物件去實作它。

2)category 中使用 @property 同樣只會產生方法宣告。若真的需要為 category 加上屬性實作,得借助 runtime 的兩個函數:objc_setAssociatedObject 與 objc_getAssociatedObject。

8. runtime 如何實作 weak 屬性

先釐清 weak 的特性:weak 表明該屬性定義了一種「非擁有關係」。設定新值時,setter 既不保留新值也不釋放舊值。這點與 assign 類似,但差別在於物件被銷毀時屬性會自動清空為 nil。

那 runtime 如何實現 weak 變數的的自動置 nil?runtime 對已註冊的類別會進行布局,並把 weak 物件放進一個雜湊表中,以 weak 所指向的物件記憶體位址作為 key。當該物件引用計數歸零而 dealloc 時,runtime 便以此位址為鍵在 weak 表中搜尋,找出所有以它為鍵的 weak 物件,將它們設為 nil。

可以寫成這樣的偽程式碼:

objc_storeWeak(&a, b):把第二個參數(賦值物件 b)的記憶體位址作為 key,把第一個參數(weak 修飾的變數 a)的記憶體位址 &a 作為 value,註冊進 weak 表。若第二個參數為 0(nil),則把 &a 從 weak 表中移除。

你可以理解為 objc_storeWeak(value, key):當 key 變 nil,就把 value 置 nil。

在 b 非 nil 時,a 與 b 指向同一個記憶體位址;b 變 nil 時 a 也變 nil,此時向 a 發送訊息不會崩潰(Objective-C 中向 nil 發送訊息是安全的)。而如果 a 由 assign 修飾,b 變 nil 時 a 仍指向原位址,成為指標,此時向 a 發送訊息極易崩潰。

以下用偽程式碼模擬 runtime 的實作:

// 使用偽代碼模擬:runtime如何實現weak屬性 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong  id obj1;  objc_initWeak(&obj1, obj); /*obj引用計數變為0,變量作用域結束*/  objc_destroyWeak(&obj1);

整體作用:透過 objc_initWeak 初始化「附帶 weak 修飾符的變數(obj1)」,並在變數作用域結束時透過 objc_destroyWeak 釋放它。

內部實作分別如下:

objc_initWeak 會先把「附帶 weak 修飾符的變數」初始化為 0(nil),然後把賦值物件作為參數呼叫 objc_storeWeak:

obj1 = 0; obj_storeWeak(&obj1, obj);

也就是說:weak 修飾的指標預設值是 nil(在 Objective-C 中向 nil 發送訊息是安全的)。

接著 objc_destroyWeak 會把 0(nil)作為參數呼叫 objc_storeWeak:

objc_storeWeak(&obj1, 0);

前面那段程式碼因此等效於:

// 使用偽代碼模擬:runtime如何實現weak屬性 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong id obj1; obj1 = 0; objc_storeWeak(&obj1, obj); /* ... obj的引用計數變為0,被置nil ... */ objc_storeWeak(&obj1, 0);

偽程式碼只是為了方便理解,下面我們實際操作一次:如何讓沒有使用 weak 修飾的 @property 擁有 weak 的效果。可以從 setter 下手:

- (void)setObject:(NSObject *)object {     objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN);     [object cyl_runAtDealloc:^{         _object = nil;     }]; }

兩個步驟:

1)在 setter 中設定關聯物件:

objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN);

2)在屬性所指物件被銷毀時清空屬性值。這一步同樣要借助 runtime:

//要銷毀的目標對象 id objectToBeDeallocated; //可以理解為一個“事件”:當上面的目標對象銷毀時,同時要發生的“事件”。 id objectWeWantToBeReleasedWhenThatHappens; objc_setAssociatedObject(objectToBeDeallocted,                      someUniqueKey,                      objectWeWantToBeReleasedWhenThatHappens,                      OBJC_ASSOCIATION_RETAIN);

思路清楚了就開始實作 cyl_runAtDealloc,分兩部分。

第一部分:建立一個類別,代表「目標物件銷毀時同時要發生的事件」,並借助 block 執行該事件。

// .h文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 這個類,可以理解為一個“事件”:當目標對象銷毀時,同時要發生的“事件”。借助block執行“事件”。 typedef void (^voidBlock)(void); @interface CYLBlockExecutor : NSObject  - (id)initWithBlock:(voidBlock)block; @end // .m文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 這個類,可以理解為一個“事件”:當目標對象銷毀時,同時要發生的“事件”。借助block執行“事件”。 #import "CYLBlockExecutor.h" @interface CYLBlockExecutor() {     voidBlock _block; } @implementation CYLBlockExecutor - (id)initWithBlock:(voidBlock)aBlock {     self = [super init];     if (self) {         _block = [aBlock copy];     }     return self; } - (void)dealloc {     _block ? _block() : nil; } @end

第二部分:核心程式碼,用 runtime 實作 cyl_runAtDealloc。

// CYLNSObject+RunAtDealloc.h文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 利用runtime實現cyl_runAtDealloc方法 #import "CYLBlockExecutor.h" const void *runAtDeallocBlockKey = &runAtDeallocBlockKey; @interface NSObject (CYLRunAtDealloc) - (void)cyl_runAtDealloc:(voidBlock)block; @end // CYLNSObject+RunAtDealloc.m文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 利用runtime實現cyl_runAtDealloc方法 #import "CYLNSObject+RunAtDealloc.h" #import "CYLBlockExecutor.h" @implementation NSObject (CYLRunAtDealloc) - (void)cyl_runAtDealloc:(voidBlock)block {     if (block) {         CYLBlockExecutor *executor = [[CYLBlockExecutor alloc] initWithBlock:block];                  objc_setAssociatedObject(self,                                              runAtDeallocBlockKey,                                                 executor,                                                 OBJC_ASSOCIATION_RETAIN);     } } @end

使用方式:先引入

#import "CYLNSObject+RunAtDealloc.h"

然後就能用了:

    NSObject *foo = [[NSObject alloc] init];     [foo cyl_runAtDealloc:^{         NSLog(@"正在釋放foo!");     }];

有興趣深入理解原理的,可以參考博文 Fun With the Objective-C Runtime: Run Code at Deallocation of Any Object。

9. @property 有哪些屬性關鍵字?

屬性可以擁有的特質分為四類:

原子性——nonatomic 特質。預設情況下編譯器合成的方法會透過鎖定機制確保原子性;具備 nonatomic 則不使用同步鎖。注意,雖然沒有名為 atomic 的特質,但寫在屬性特質中編譯器不會報錯。若自訂存取方法,就應遵循與屬性特質相符的原子性。

讀寫權限——readwrite(讀寫)、readonly(唯讀)

記憶體管理語義——assign、strong、weak、unsafe_unretained、copy

方法名稱——getter=<name>、setter=<name>

getter=<name> 的寫法:

  @property (nonatomic, getter=isOn) BOOL on;

(setter=<name> 不常用也不推薦,故不在此列出。)

另有不常用的 nonnull、null_resettable、nullable。

10. weak 屬性需要在 dealloc 中置 nil 嗎?

不需要。在 ARC 環境下,無論強指標還是弱指標都無需在 dealloc 設為 nil,ARC 會自動處理。

即便編譯器不幫我們做,weak 也不需要手動置 nil——如前文所述,物件被銷毀時屬性值本身就會自動清空。

11. @synthesize 與 @dynamic 分別有何作用?

1)@property 有兩個對應關鍵字:@synthesize 與 @dynamic。兩者都不寫時,預設等同 @synthesize var = _var;

2)@synthesize 的語義是:若你沒有手動實作 setter 與 getter,編譯器會自動為你加上。

3)@dynamic 則告訴編譯器:屬性的 setter 與 getter 由使用者自行實作,不要自動產生(readonly 屬性只需提供 getter)。若宣告為 @dynamic var 卻未提供對應方法,編譯時不會報錯,但執行到 instance.var = someVar 時會因缺少 setter 而崩潰;執行到 someVar = var 時也會因缺少 getter 而崩潰。編譯期不檢查、執行期才查找方法,這就是所謂的動態綁定。

12. ARC 下不顯式指定任何屬性關鍵字時,預設是什麼?

對應基本資料型別,預設為 atomic, readwrite, assign。

對於普通的 Objective-C 物件,預設為 atomic, readwrite, strong。

參考連結:

  • Objective-C ARC: strong vs retain and weak vs assign

  • Variable property attributes or Modifiers in iOS

13. 為什麼 NSString(或 NSArray、NSDictionary)常用 copy?改用 strong 會有什麼問題?

1)因為父類指標可以指向子類物件。使用 copy 的目的是讓本物件的屬性不受外界影響——無論傳入的是可變還是不可變物件,自身持有的都是一個不可變副本。

2)若使用 strong,這個屬性就有可能指向一個可變物件;一旦該可變物件在外部被修改,就會連帶影響這個屬性。

copy 表達的擁有關係與 strong 類似,但 setter 不保留新值,而是複製一份。當屬性型別為 NSString 時,常用此特質保護封裝性,因為傳入的新值可能指向 NSMutableString 實例。若不複製,設定完屬性後字串值可能在物件不知情的情況下被改動。因此要複製一份不可變字串,確保值不會無意間變動。只要屬性實作用的物件是可變的,就應該在設定新值時複製。

要理解這件事,先要知道非集合類物件的 copy 行為:

對 immutable 物件做 copy 是指標複製(淺複製),mutableCopy 是內容複製;對 mutable 物件而言,copy 與 mutableCopy 都是內容複製。用程式碼表示:

  • [immutableObject copy] // 淺複製

  • [immutableObject mutableCopy] // 深複製

  • [mutableObject copy] // 深複製

  • [mutableObject mutableCopy] // 深複製

例如:

NSMutableString *string = [NSMutableString stringWithString:@"origin"];//copy NSString *stringCopy = [string copy];

查看記憶體會發現 string 與 stringCopy 的位址不同,說明此時做的是內容拷貝、深拷貝。即使接著執行:

[string appendString:@"origion!"]

stringCopy 的值也不會改變;但若不使用 copy,stringCopy 的值就會被改掉。集合類物件同理。

所以,用 @property 聲明 NSString、NSArray、NSDictionary 時常用 copy,是因為它們有對應的可變類型,彼此之間可能進行賦值操作;為確保物件內的值不被無意間改動,應在設定新值時複製一份。

參考連結:iOS 集合的深複製與淺複製

14. @synthesize 合成實例變數的規則?若已有名為 _foo 的實例變數,還會自動合成嗎?

先說明一個概念:實例變數 = 成員變數 = ivar,這幾種說法指的是同一件事。

正如 Apple 官方文件 You Can Customize Synthesized Instance Variable Names 所述:

使用屬性時,編譯器會自動撰寫存取方法,這個過程叫「自動合成」。它由編譯器在編譯期執行,所以編輯器裡看不到這些合成方法的原始碼。除了產生方法,編譯器還會自動加入適當型別的實例變數,並在屬性名前加底線作為名稱。

@interface CYLPerson : NSObject  @property NSString *firstName;  @property NSString *lastName;  @end

上例會產生 _firstName 與 _lastName 兩個實例變數。也可以在實作檔中透過 @synthesize 指定名稱:

@implementation CYLPerson  @synthesize firstName = _myFirstName;  @synthesize lastName = _myLastName;  @end

這樣產生的實例變數就是 _myFirstName 與 _myLastName,不再使用預設名。一般無須修改預設名,但若你不喜歡用底線命名,可以用這個方式改成自己想要的名字。我仍推薦使用預設方案,因為大家都遵循同一套規則時,程式碼的可讀性最好。

總結 @synthesize 合成實例變數的規則:

1)若指定了成員變數名稱,會產生該名稱的成員變數。

2)若該成員變數已存在,就不再產生。

3)若是 @synthesize foo;,還會產生一個名為 foo 的成員變數——也就是說,未指定名稱時會自動產生與屬性同名的成員變數。

4)若是 @synthesize foo = _foo;,則不會產生名為 foo 的成員變數。

假如 property 名為 foo,且已存在名為 _foo 的實例變數,還會自動合成新變數嗎?不會。如下圖:

15. 有了自動合成之後,@synthesize 還有哪些使用場景?

回答前先釐清:什麼情況下不會自動合成?

  • 同時重寫了 setter 與 getter 時

  • 重寫了唯讀屬性的 getter 時

  • 使用了 @dynamic 時

  • 在 @protocol 中定義的所有屬性

  • 在 category 中定義的所有屬性

  • 覆載的屬性

當你在子類中覆載父類的屬性時,必須使用 @synthesize 手動合成 ivar。

除了後三條,前面幾項可以歸納出一個規律:當你想手動管理 @property 的所有內容時,你會嘗試透過自行實作全部存取方法或使用 @dynamic 來達成;此時編譯器會認為你打算手動管理,於是停用自動合成。

因為有了自動合成,多數開發者已習慣不手動定義 ivar。但一旦你需要使用 ivar,而自動合成又失效了,就必須借助 @synthesize 手動合成。

@synthesize 還有一個應用場景,但不建議使用:透過它指定實例變數的名稱(如上題所示)。一般無須修改預設名,若所有人都堅持同一套方案,程式碼大家都能讀懂。

舉例說明應用場景:

結果編譯器報錯:

當你同時重寫了 setter 與 getter 時,系統就不會產生 ivar。這時有兩種選擇:

  • 手動建立 ivar

  • 使用 @synthesize foo = _foo; 關聯 @property 與 ivar

更多資訊請參考:When should I use @synthesize explicitly?

16. 向 nil 物件發送訊息會發生什麼?

在 Objective-C 中向 nil 發送訊息是完全合法的——只是執行時不會有任何作用:

如果方法回傳的是物件,訊息會回傳 0(nil)。例如:

Person * motherInlaw = [[aPerson spouse] mother];

若 spouse 為 nil,則發送給 nil 的 mother 也會回傳 nil。

1)若方法回傳指標型別,且大小小於或等於 sizeof(void*),或為 float、double、long double、long long 等整數純量,發送給 nil 的訊息會回傳 0。

2)若回傳結構體,會回傳全欄位皆為 0 的結構體。

3)不屬於上述情況時,回傳值是未定義的。

具體原因:Objective-C 是動態語言,每個方法在執行時都會被轉為訊息發送,即 objc_msgSend(receiver, selector)。

貼一段 runtime 的原始碼來說明:

// runtime.h(類在runtime中的定義) // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong
struct objc_class {   Class isa OBJC_ISA_AVAILABILITY; //isa指針指向Meta Class,因為Objc的類的本身也是一個Object,為了處理這個關系,runtime就創造了Meta Class,當給類發送[NSObject alloc]這樣消息時,實際上是把這個消息發給了Class Object   #if !__OBJC2__   Class super_class OBJC2_UNAVAILABLE; // 父類   const char *name OBJC2_UNAVAILABLE; // 類名   long version OBJC2_UNAVAILABLE; // 類的版本信息,默認為0   long info OBJC2_UNAVAILABLE; // 類信息,供運行期使用的一些位標識   long instance_size OBJC2_UNAVAILABLE; // 該類的實例變量大小   struct objc_ivar_list *ivars OBJC2_UNAVAILABLE; // 該類的成員變量鏈表   struct objc_method_list **methodLists OBJC2_UNAVAILABLE; // 方法定義的鏈表   struct objc_cache *cache OBJC2_UNAVAILABLE; // 方法緩存,對象接到一個消息會根據isa指針查找消息對象,這時會在method Lists中遍歷,如果cache了,常用的方法調用時就能夠提高調用的效率。   struct objc_protocol_list *protocols OBJC2_UNAVAILABLE; // 協議鏈表   #endif   } OBJC2_UNAVAILABLE;

向物件發送訊息時,runtime 會依物件的 isa 指標找到它實際所屬的類別,再在該類別與父類的方法列表中尋找方法執行。而回傳內容是具體呼叫時才產生的。回到本題:若向 nil 發送訊息,在查找 isa 指標時位址就是 0,直接回傳,因此不會出錯。

17. [obj foo] 與 objc_msgSend() 之間的關係?

原因同上題:該方法編譯後就是一次 objc_msgSend() 呼叫,大致如下:

((void ()(id, SEL))(void )objc_msgSend)((id)obj, sel_registerName("foo"));

也就是說,[obj foo]; 在動態編譯時會被轉為 objc_msgSend(obj, @selector(foo));。

18. 什麼時候會出現 unrecognized selector 例外?

簡單說:當你向某物件發送一個它並未實作的方法時。這可以透過「訊息轉發」來處理。

流程如下:向物件發送訊息時,runtime 依 isa 指標找到所屬類別,再依序在該類與父類的方法列表中尋找;若一直找到最頂層父類仍找不到,程式執行時就會崩潰並拋出 unrecognized selector sent to XXX。但在崩潰之前,Objective-C runtime 會給你三次挽救的機會:

Method resolution

runtime 會呼叫 +resolveInstanceMethod: 或 +resolveClassMethod:,讓你有機會提供實作。若你動態加入方法並回傳 YES,runtime 會重新啟動一次訊息發送;若回傳 NO,則進入下一步。

Fast forwarding

若目標物件實作了 -forwardingTargetForSelector:,runtime 會呼叫它,讓你把訊息轉發給其他物件。只要回傳的不是 nil 或 self,整個發送流程就會重啟,只是接收者換成你回傳的物件。之所以叫 Fast,是因為這一步不會建立任何新物件;下一步則會建立 NSInvocation,相對較慢。

Normal forwarding

最後一次機會。runtime 會先發送 -methodSignatureForSelector: 取得函數的參數與回傳型別。若回傳 nil,則發出 -doesNotRecognizeSelector:,程式此時崩潰。若回傳了函數簽章,runtime 會建立 NSInvocation 並向目標物件發送 -forwardInvocation:。

19. 一個 Objective-C 物件如何進行記憶體布局?(考慮有父類的情況)

  • 所有父類的成員變數與自己的成員變數,都存放在該物件對應的儲存空間中。

  • 每個物件內部都有一個 isa 指標指向它的類別物件,類別物件中存放著:

1)物件方法列表(該物件能接收的訊息列表,保存在其對應的類別物件中)

2)成員變數列表

3)屬性列表

類別物件內部也有一個 isa 指標指向元類別(meta class),元類別中存放的是類別方法列表;類別物件內部還有一個 superclass 指標指向父類。

1)根物件是 NSObject,它的 superclass 指標指向 nil。

2)類別物件既然稱為物件,也是一個實例。類別物件中也有 isa 指標指向它的元類別,即類別物件是元類別的實例。元類別內部存放類別方法列表;根元類別的 isa 指標指向自己,superclass 指標指向 NSObject 類。

如圖:

20. 物件的 isa 指標指向什麼?有何作用?

指向它的類別物件,從而能透過類別物件找到該物件上的方法。

21. 下面的程式碼輸出什麼?

@implementation Son : Father - (id)init {     self = [super init];     if (self) {         NSLog(@"%@", NSStringFromClass([self class]));         NSLog(@"%@", NSStringFromClass([super class]));     }     return self; } @end

答案:兩者都輸出 Son。

NSStringFromClass([self class]) = Son NSStringFromClass([super class]) = Son

解惑(以下內容摘自微博 @Chun_iOS 的博文《刨根問底 Objective-C Runtime(1)- Self & Super》):

這題考察的是對 self 與 super 的理解。self 是類別的隱藏參數,指向當前呼叫該方法的類別實例。而 super 是一個魔法關鍵字,本質上是編譯器標記,它和 self 指向同一個訊息接收者。

上例中無論呼叫 [self class] 還是 [super class],接收訊息的物件都是當前 Son *xxx 這個物件。差別在於:super 告訴編譯器,呼叫 class 這個方法時要從父類的方法列表中開始查找,而不是本類。

使用 self 呼叫時,從當前類的方法列表開始找,找不到再往父類找;使用 super 時則從父類的方法列表開始找。

真的是這樣嗎?繼續看。用 clang 改寫:

$ clang -rewrite-objc test.m

發現上述程式碼被轉換為:

NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_a5cecc_mi_0, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("class")))); NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_a5cecc_mi_1, NSStringFromClass(((Class *)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){ (id)self, (id)class_getSuperclass(objc_getClass("Son")) }, sel_registerName("class"))));

可以看到,呼叫 [self class] 時會轉為 objc_msgSend,函數定義為:

id objc_msgSend(id self, SEL op, ...)

self 作為第一個參數傳入。

而呼叫 [super class] 時會轉為 objc_msgSendSuper,函數定義為:

id objc_msgSendSuper(struct objc_super *super, SEL op, ...)

第一個參數是 objc_super 結構體,其定義如下:

struct objc_super {    __unsafe_unretained id receiver;    __unsafe_unretained Class super_class; };

結構體有兩個成員:第一個是 receiver,類似 objc_msgSend 的第一個參數 self;第二個記錄當前類的父類。

所以呼叫 [self class] 時,實際先呼叫 objc_msgSend,第一個參數是 Son 當前實例,然後在 Son 中找 - (Class)class,沒有,去父類 Father 找,也沒有,最後在 NSObject 中找到。而 - (Class)class 的實作就是回傳 self 的類別,故輸出 Son。

runtime 原始碼對 - (Class)class 的實作:

- (Class)class {     return object_getClass(self); }

而呼叫 [super class] 時會轉為 objc_msgSendSuper。第一步先建構 objc_super 結構體,第一個成員是 self,第二個成員是 (id)class_getSuperclass(objc_getClass("Son")),結果為 Father。第二步在 Father 中找 - (Class)class,沒有,再到 NSObject 找,找到了。最後內部使用 objc_msgSend(objc_super->receiver, @selector(class)) 呼叫,此時已與 [self class] 相同,故輸出仍是 Son。

22. runtime 如何透過 selector 找到對應的 IMP 位址?(分別考慮類別方法與實例方法)

每個類別物件中都有一個方法列表,記錄著方法名稱、方法實作與參數型別。selector 本質上就是方法名稱,透過這個名稱即可在方法列表中找到對應的方法實作。

23. 使用 runtime Associate 關聯的物件,需要在主物件 dealloc 時釋放嗎?

  • 在 ARC 下不需要

  • 在 MRC 中,對於使用 retain 或 copy 策略的,無論 MRC 還是 ARC 都不需要

2011 年版本的 Apple API 官方文件 Associative References 一節中有一個 MRC 環境下的例子:

// 在MRC下,使用runtime Associate方法關聯的對象,不需要在主對象dealloc的時候釋放 // https://weibo.com/luohanchenyilong/ (微博@iOS程序犭袁) // https://github.com/ChenYilong // 摘自2011年版本的Apple API 官方文檔 - Associative References static char overviewKey; NSArray *array =      [[NSArray alloc] initWithObjects:@"One", @"Two", @"Three", nil]; // For the purposes of illustration, use initWithFormat: to ensure // the string can be deallocated NSString *overview =      [[NSString alloc] initWithFormat:@"%@", @"First three numbers"];      objc_setAssociatedObject (      array,     &overviewKey,     overview,     OBJC_ASSOCIATION_RETAIN ); [overview release]; // (1) overview valid [array release]; // (2) overview invalid

文件指出:在第 1 點時,overview 字串仍然有效,因為 OBJC_ASSOCIATION_RETAIN 策略指定了 array 會保留關聯物件;而當 array 在第 2 點被釋放時,overview 會被 release,此時也一併被配置掉。

既然關聯物件會被銷毀,具體時間點是什麼?根據 WWDC 2011 Session 322(第 36 分 22 秒)發布的記憶體銷毀時間表,被關聯的物件在其生命週期內會比物件本身晚很多才釋放——它們會在 NSObject -dealloc 呼叫的 object_dispose() 方法中釋放。

物件記憶體銷毀時間表分為四個步驟:

// 對象的內存銷毀時間表 // https://weibo.com/luohanchenyilong/ (微博@iOS程序犭袁) // https://github.com/ChenYilong // 根據 WWDC 2011, Session 322 (36分22秒)中發布的內存銷毀時間表   1. 調用 -release :引用計數變為零      * 對象正在被銷毀,生命周期即將結束.      * 不能再有新的 __weak 弱引用, 否則將指向 nil.      * 調用 [self dealloc]   2. 父類 調用 -dealloc      * 繼承關系中最底層的父類 在調用 -dealloc      * 如果是 MRC 代碼 則會手動釋放實例變量們(iVars)      * 繼承關系中每一層的父類 都在調用 -dealloc  3. NSObject 調 -dealloc      * 只做一件事:調用 Objective-C runtime 中的 object_dispose() 方法  4. 調用 object_dispose()      * 為 C++ 的實例變量們(iVars)調用 destructors      * 為 ARC 狀態下的 實例變量們(iVars) 調用 -release      * 解除所有使用 runtime Associate方法關聯的對象      * 解除所有 __weak 引用      * 調用 free()

24. 類別方法與實例方法有什麼本質區別與聯繫?

類別方法:

  • 屬於類別物件

  • 只能透過類別物件呼叫

  • 其中的 self 是類別物件

  • 可以呼叫其他類別方法

  • 不能存取成員變數

  • 不能直接呼叫物件方法

實例方法:

  • 屬於實例物件

  • 只能透過實例物件呼叫

  • 其中的 self 是實例物件

  • 可以存取成員變數

  • 可直接呼叫其他實例方法

  • 也可以透過類別名稱呼叫類別方法

未完待續。

下一篇文章將發布於此處。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved