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

iOS 開發常見問題整理:記憶體、多執行緒、網路與 Objective-C 基礎

編輯:iOS 開發綜合

這份筆記把 iOS/Objective-C 開發與面試中最常被問到的問題做了歸納,分成記憶體管理、多執行緒、第三方套件原理、語言特性、C 語言基礎、網路協定與經典面試題七大主題,方便逐塊複習。

一、記憶體管理與關鍵字修飾符

__block 與 __weak 的差別

  1. __block 在 ARC 與 MRC 下都能使用,除了物件之外,也能修飾基本資料型別。
  2. __weak 只能在 ARC 下使用,而且只能修飾物件(如 NSString),無法修飾基本型別(如 int)。
  3. __block 修飾的變數可以在 block 內部被重新賦值,__weak 則不行。

copy 與 retain

  1. copy 建立的是一個內容相同的新物件,retain 只是增加引用計數,指向同一個物件。
  2. copy 是內容拷貝,retain 是指針拷貝。
  3. copy 並非永遠都是深拷貝。對 NSString 這種不可變物件確實如此,但若對一個 NSArray 做 copy,實際上只是拷貝了陣列中元素的指標,這就是所謂的「淺複製」。

舉例來說,NSString *newPt = [pt copy]; 會在堆上配置一段新記憶體存放 "abc"(假設位址 0x1122),同時在堆疊上為 newPt 配置空間(假設位址 0xaacc),內容是 0x1122。此時 retainCount 增加 1,交給 newPt 管理那段記憶體。

assign 與 retain

  1. assign 是簡單賦值,不改變引用計數。
  2. NSString *newPt = [pt assign]; 這種寫法下 newPt 和 pt 完全相同,位址都是 0xaaaa、內容都是 0x1111,newPt 只是 pt 的別名;對其中一個的操作等同於對另一個操作,因此 retainCount 不需增加。
  3. retain 使用引用計數:retain 讓計數加 1,release 讓計數減 1,當計數歸零時 dealloc 被呼叫,記憶體回收。
  4. NSString *newPt = [pt retain]; 此時 newPt 的位址不再是 0xaaaa(可能是 0xaabb),但內容仍為 0x1111。newPt 與 pt 都能管理 "abc" 所在的記憶體,因此 retainCount 需要加 1。

readonly / readwrite / nonatomic

  • readonly:唯讀屬性。實作中只需提供 getter;若使用 @synthesize,編譯器也會只解析出 getter。
  • readwrite:讀寫屬性,也是預設行為,getter 與 setter 都需在 @implementation 中實作(或交由 @synthesize 解析)。
  • nonatomic:非原子性存取,賦值時不加鎖,多執行緒並發存取時效能較好。若不加上這個修飾詞,預設兩個存取方法都是原子性的事務存取。

strong 與 weak

  1. strong 與 weak 只有開啟 ARC 時才需要,此時你不能使用 retain/release/autorelease,因為 ARC 會代勞。其中 strong 相當於舊的 retain,weak 相當於 assign。
  2. 唯一必須用 weak(預設是 strong)的情況,是為了避免循環引用(retain cycle)——父類 retain 子類,子類又 retain 父類,結果雙方都無法釋放。
  3. 宣告為 weak 的指標,一旦指向的位址被釋放,該指標會自動被設為 nil,這能有效避免成為「野指標」。

ARC(Automatic Reference Counting)

ARC 會在編譯階段自動把 retain/release 插入程式碼中,原本需要手動維護的引用計數改由編譯器完成。這項機制自 iOS 5 與 Mac OS X 10.7 起導入,搭配 Xcode 4.2 之後即可使用。

strong、weak、copy 的實務搭配

  • IBOutlet 通常宣告為 weak;NSString 用 copy;delegate 一般用 weak;其餘依情況判斷。大致原則是:類別「內部」擁有的屬性用 strong,屬於「外部」參考的用 weak——本質上就是一個所有權問題。關鍵是小心循環引用導致記憶體無法釋放。
  • 不用 ARC 時就會看到大量 retain。
  • 寫下 @synthesize abc = _abc; 時,系統會自動幫你宣告一個 _abc 實例變數。
  • 使用 assign:基本資料型別(NSInteger)與 C 型別(int、float、double、char 等)。
  • 使用 copy:NSString。
  • 使用 retain:其他 NSObject 及其子類。

淺複製與深複製

淺複製只複製指向物件的指標,不複製參考物件本身;深複製則會複製參考物件本身。也就是說,若有 A 物件,淺複製得到 A_copy 之後,兩者指向同一塊記憶體,修改 A_copy 會連帶改動 A——這顯然違背了複製的初衷。深複製則在記憶體中產生兩份彼此獨立的物件。有個說法很傳神:淺複製像你和你的影子,你出事影子也一起完;深複製像你和你的克隆人,你出事了克隆人還活著。

動態記憶體配置的常見錯誤

下面幾個經典反例,幾乎涵蓋了指標與變數生命週期的主要陷阱:

// 錯誤一:傳值傳入,函式內改動形參不會影響呼叫端
void GetMemory(char *p) { p = (char *)malloc(100); }

// 錯誤二:回傳函式內的區域自動變數,函式返回後記憶體已被釋放
char *GetMemory(void) { char p[] = "hello world"; return p; }

// 正確做法:傳入指標的指標,並檢查配置是否成功
void GetMemory(char **p, int num) {
    *p = (char *)malloc(num);
    if (*p == NULL) {
        // 處理配置失敗
    }
}

// 正確做法:配置後檢查,free 之後指標要設為 NULL
char *str = (char *)malloc(100);
if (str == NULL) { /* 處理失敗 */ }
strcpy(str, "hello");
free(str);
str = NULL;

另外,free 之後不把指標設為 NULL,會留下可能指向已釋放記憶體的「野指標」;呼叫端也別忘了釋放 malloc 來的記憶體。

volatile 的含義

宣告為 volatile 的變數,代表它可能在程式意料之外的時機被改變,因此編譯器不能假設它的值,每次使用都必須重新讀取,而不能沿用暫存器中的副本。典型場景包括:平行裝置的硬體暫存器(如狀態暫存器)、中斷服務常式會存取的非常自動變數,以及多執行緒應用中被多個任務共享的變數。

兩個常見延伸問題:變數可以同時是 const 與 volatile 嗎?可以,例如唯讀的狀態暫存器——它可能被硬體改變(volatile),但程式不應去修改它(const)。指標可以是 volatile 嗎?可以,例如中斷常式修改一個指向 buffer 的指標時。

二、多執行緒與 GCD

dispatch_async 的標準寫法

為了避免介面在處理耗時操作(網路請求、檔案 IO、資料庫讀寫)時卡住,我們會把這些工作丟到另一條執行緒,完成後再回主執行緒更新 UI。用 GCD 實作這個流程比 NSThread、NSOperation 都簡潔:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 耗時操作
    dispatch_async(dispatch_get_main_queue(), ^{
        // 更新介面
    });
});

以非同步下載圖片為例:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSURL *url = [NSURL URLWithString:@"https://avatar.csdn.net/2/C/D/1_totogo2010.jpg"];
    NSData *data = [[NSData alloc] initWithContentsOfURL:url];
    UIImage *image = [[UIImage alloc] initWithData:data];
    if (data != nil) {
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });
    }
});

系統為每個 App 提供了三個並行佇列,它們是全域的、只有優先級不同,不需要自行建立,只要用 dispatch_get_global_queue 取得即可;此外系統預設還有一條序列佇列 main_queue:

dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t mainQ   = dispatch_get_main_queue();

雖然 dispatch queue 是引用計數物件,但這兩個都是全域佇列,不需要 retain 或 release。

dispatch_group_async:等待一組任務

它可以監聽一組任務是否全部完成,完成後再執行其他操作。例如同時跑三個下載任務,全部完成後才通知介面:

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, queue, ^{ [NSThread sleepForTimeInterval:1]; NSLog(@"group1"); });
dispatch_group_async(group, queue, ^{ [NSThread sleepForTimeInterval:2]; NSLog(@"group2"); });
dispatch_group_async(group, queue, ^{ [NSThread sleepForTimeInterval:3]; NSLog(@"group3"); });

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    NSLog(@"updateUi");
});

dispatch_release(group);

執行結果中,三個任務依序各間隔一秒印出,第三個任務結束後才印出 updateUi。

dispatch_barrier_async:柵欄

它會等前面的任務執行結束後才執行,而且它後面的任務也要等它跑完才會啟動:

dispatch_queue_t queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{ [NSThread sleepForTimeInterval:2]; NSLog(@"dispatch_async1"); });
dispatch_async(queue, ^{ [NSThread sleepForTimeInterval:4]; NSLog(@"dispatch_async2"); });

dispatch_barrier_async(queue, ^{
    NSLog(@"dispatch_barrier_async");
    [NSThread sleepForTimeInterval:4];
});

dispatch_async(queue, ^{ [NSThread sleepForTimeInterval:1]; NSLog(@"dispatch_async3"); });

注意各段之間的時間差,就能看出執行順序完全符合上述規則。

dispatch_apply:重複執行 N 次

dispatch_apply(5, globalQ, ^(size_t index) {
    // 執行 5 次
});

信號量與佇列的暫停恢復

暫停佇列會阻止與該佇列相關的所有程式碼運行,但別忘了要恢復——暫停與恢復的關係就像記憶體管理中的 retain 與 release:

dispatch_suspend(myQueue);   // 暫停計數 +1
dispatch_resume(myQueue);    // 暫停計數 -1,歸零才真正恢復

另外要注意,dispatch_suspend(與 dispatch_resume)在主執行緒上是不生效的。

在主執行緒執行程式碼

有些操作無法在背景佇列進行,必須回到主執行緒(每個 App 都有一條)。UI 繪製以及任何對 NSNotificationCenter 的呼叫都屬於這一類:

dispatch_sync(dispatch_get_main_queue(), ^{
    [self dismissLoginWindow];
});

NSOperationQueue

NSOperationQueue 是存放 NSOperation 的集合類,操作與操作佇列的關係,大致可以類比 Java 中的執行緒與執行緒池,同樣用來處理 iOS 的多執行緒問題。要注意的是,它雖然叫「佇列」,放入的操作卻不是嚴格的先進先出——因為兩個操作提交的時間間隔很近時,執行緒池中的哪條執行緒先啟動並不確定。可以把它想像成銀行的取票與叫號系統:先取票的人不一定先辦完。實務上,它的主要價值在於協助你把多執行緒編程寫得更乾淨。

tableView 滑動卡頓

主要原因通常是從快取或本地讀取圖片交給 UIImage 時所花的時間。解法是把讀取與解碼放到子執行緒:

NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:app.icon]];
UIImage *image   = [UIImage imageWithData:imgData];

而把 image 實際賦值給 view 的動作,則要回到主執行緒。核心原則是:子執行緒不能更新 UI,所有 UI 更新都必須在主執行緒進行。

子執行緒中的 NSTimer

在子執行緒加入 NSTimer 時,必須手動為該執行緒的 RunLoop 添加 timer,否則計時器不會循環觸發。

單例中的 NSMutableArray

若單例裡有一個 NSMutableArray,又可能被多個地方同時遍歷與修改,建議改用原子屬性並搭配 strong,同時自行實作遍歷與修改的方法,並在其中加上 Lock/Unlock。

用 __weak 避免循環引用

__weak ViewController *weakSelf = self;

在 GCD 的區塊中使用 __weak,可以避免區塊強持有 self 所導致的記憶體無法釋放。

dispatch_once 實作單例

static ClassA *classA = nil;

+ (ClassA *)sharedManager {
    @synchronized(self) {
        if (!classA) {
            classA = [[super allocWithZone:NULL] init];
        }
        return classA;
    }
}

+ (id)allocWithZone:(NSZone *)zone { return [[self sharedManager] retain]; }
- (id)copyWithZone:(NSZone *)zone { return self; }
- (id)retain { return self; }
- (NSUInteger)retainCount { return NSUIntegerMax; }
- (oneway void)release { }
- (id)autorelease { return self; }
- (void)dealloc { }

單例模式要求該類別在整個應用中只存在一個實例。透過覆寫記憶體管理方法,讓外部無論怎麼 retain/release/copy 都不會破壞這個唯一性。

三、SDWebImage 的內部實作流程

呼叫入口 setImageWithURL:placeholderImage:options: 後,會先把 placeholderImage 顯示出來,接著由 SDWebImageManager 依 URL 開始處理圖片:

  1. 進入 SDWebImageManager-downloadWithURL:delegate:options:userInfo:,交給 SDImageCache 透過 queryDiskCacheForKey:delegate:userInfo: 查詢快取。
  2. 先查記憶體快取。若命中,SDImageCacheDelegate 回呼 imageCache:didFindImage:forKey:userInfo: 給 SDWebImageManager。
  3. SDWebImageManagerDelegate 再回呼 webImageManager:didFinishWithImage: 給 UIImageView+WebCache 等前端,完成顯示。
  4. 若記憶體沒有,就建立一個 NSInvocationOperation 加入佇列,開始從硬碟查找。這一步在 NSOperation 中進行,因此結果回呼會切回主執行緒執行 notifyDelegate:。
  5. 若從硬碟讀到圖片,就把它加入記憶體快取(若可用記憶體過小,會先清空記憶體快取),接著回呼 imageCache:didFindImage:forKey:userInfo:,進而顯示圖片。
  6. 若硬碟快取目錄也讀不到,代表所有快取都沒有這張圖,於是回呼 imageCache:didNotFindImageForKey:userInfo:,開始下載。
  7. 共用或重新建立一個 SDWebImageDownloader 開始下載,底層由 NSURLConnection 執行,並透過 delegate 判斷下載中、完成與失敗。
  8. connection:didReceiveData: 中利用 ImageIO 做出依下載進度遞增的載入效果。
  9. connectionDidFinishLoading: 把資料交給 SDWebImageDecoder 解碼。解碼在一個 NSOperationQueue 中完成,不會拖慢主執行緒的 UI。若需要對圖片做二次處理,放在這裡效率最好。
  10. 解碼完成後,於主執行緒呼叫 notifyDelegateOnMainThreadWithInfo:,透過 imageDecoder:didFinishDecodingImage:userInfo: 回呼 SDWebImageDownloader。
  11. imageDownloader:didFinishWithImage: 回呼 SDWebImageManager,告知下載完成。
  12. 通知所有 downloadDelegates 下載完成,回呼給需要的地方顯示圖片。
  13. 把圖片同時存入 SDImageCache 的記憶體與硬碟快取;寫檔同樣以獨立的 NSInvocationOperation 進行,避免拖慢主執行緒。

SDImageCache 在初始化時會註冊一些通知,在記憶體警告或 App 進入背景時清理記憶體快取,在 App 結束時清理過期的圖片。此外 SDWebImage 也提供了 UIButton+WebCache 與 MKAnnotationView+WebCache,方便各類元件直接使用;SDWebImagePrefetcher 則可以預先下載圖片。

從整個流程可以看出,呼叫 setImageWithURL: 時它已經幫你處理完這麼多細節。若你需要在某個具體時點插入自己的邏輯,覆寫對應方法即可。例如下載某張圖片時想響應進度與完成事件:

SDWebImageManager *manager = [SDWebImageManager sharedManager];
[manager downloadImageWithURL:imagePath2
                      options:SDWebImageRetryFailed
                     progress:^(NSInteger receivedSize, NSInteger expectedSize) {
    NSLog(@"顯示當前進度");
}
                    completed:^(UIImage *image, NSError *error,
                                SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
    NSLog(@"下載完成");
}];

對入門者而言,直接用 sd_setImageWithURL: 的各種變體,就足以獲得相當不錯的圖片快取能力。

四、Objective-C 語言特性

@synthesize 與 @dynamic

  • @synthesize:若開發者沒有自行實作,編譯器會自動生成符合屬性宣告的 getter/setter。
  • @dynamic:告訴編譯器,屬性的存取方法由開發者自行實作,不要自動生成。唯讀屬性需自行提供 getter,讀寫屬性則需同時提供 getter 與 setter。

類別(Category)的作用與限制

三個主要作用:把類別的實作分散到多個檔案或框架中;為私有方法建立前向引用;向物件加入非正式協議。

兩個主要限制:無法為類別新增實例變數(類別沒有位置容納它們,實務上可用字典物件繞過);名稱衝突——若類別中的方法與原始類別同名,類別具有更高優先級,會完全取代原始方法且無法再呼叫回去。

類別與繼承的差異

category 可以在不獲悉、不改變原始程式碼的前提下增加新方法,只能新增、不能刪除或修改;一旦與原有方法同名,category 會覆蓋原方法。而繼承則可以新增、修改、刪除方法,也能新增屬性。

類別與類別擴展(Extension)

兩者的差別在於 extension 可以新增屬性,而且它宣告的方法必須被實作。可以把 extension 理解為一個私有的 category。

協議與 Java 介面的差異

OC 的 protocol 有 formal 與 informal 兩層含義,前者等同 Java 的介面;informal protocol 中的方法屬於設計模式範疇,不強制實作,但一旦實作就會改變類別的行為。現在 protocol 已用 @required 與 @optional 兩個修飾詞把兩者統一規範起來。

KVC 與 KVO

KVC(Key-Value Coding)是一種以字串標識屬性的間接存取機制,不必直接呼叫存取方法即可讀寫屬性,很多情況下能大幅簡化程式碼。當你呼叫 [self valueForKey:@"someKey"] 時,執行期會依序嘗試:找 someKey 方法(實務上也會找 getSomeKey)、找 someKey 實例變數(也會找 _someKey),若都找不到則呼叫 -valueForUndefinedKey:;若該方法也未實作,就會拋出 NSUndefinedKeyException。valueForUndefinedKey: 的設計目的,是讓物件在錯誤發生前還有一次機會自行回應這個請求。

KVO(Key-Value Observing)則提供觀察某屬性變化的能力。當觀察者註冊了某屬性後,被觀察物件的 isa 指標會被改寫,指向一個中間類別而非真正的類別,藉此攔截變化通知。也正因如此,程式最好不要依賴 isa 指標的實際指向,呼叫類別方法時應明確使用物件所屬的類別名稱。

[self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];

#pragma mark KVO
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
                        change:(NSDictionary *)change context:(void *)context {
    if ([keyPath isEqualToString:@"highlighted"]) {
        [self setNeedsDisplay];
    }
}

target-action 機制

目標是動作訊息的接收者。一個控制項(更常見的是它的 cell)以插座變數(outlet)的形式持有動作訊息的目標。動作則是控制項送給目標的訊息;從目標的角度看,它是為了回應動作而實作的方法。App 需要某種機制來把事件與指令做翻譯,這就是 target-action 機制。

動態綁定與執行期

動態綁定把「要呼叫哪個方法」的決定延後到執行期。編譯時,方法呼叫並未與程式碼綁定,只有訊息真正送出後才確定被呼叫的程式碼。執行環境會透過接收者的 isa 指標找到物件的類別,再據此找出方法。你不需要在 Objective-C 程式碼中做任何額外工作,就能自動享受動態綁定的好處。

所謂「OC 是執行期語言」,重點在於多態:把資料型別的確定從編譯時推遲到執行時。不同物件以自己的方式回應同一個訊息,就是多態。

delegate 與 Notification 的選擇

delegate 針對一對一關係,且接收者可以把值回傳給發送者;notification 則可對一對一、一對多、甚至沒有接收者,且接收者無法回傳值。因此:當發送者需要接收者的某項功能回饋值時用 delegate;只是要通知多個物件某個事件已發生時用 notification。

兩者更本質的差異是控制鏈(has-a):協議存在明確的控制關係,通知沒有。代理側重「一一對應的委託關係」,而通知只負責廣播,不关心有多少人收到並處理。

代理(delegate)與推送(push notification)

代理的目的是改變或傳遞控制鏈,讓一個類別能在特定時機通知其他類別,而不必持有那些類別的指標,藉此降低框架複雜度;它有點類似 Java 中的回呼監聽機制。

推送通知則是伺服器端主動 push 的一種技術,與一般客戶端主動 pull 的模式相反。以 APNS 為例,整個流程可分三階段:Provider(你的服務器)把要發送的消息與目標裝置識別碼打包送給 APNS;APNS 在已註冊的裝置清單中查找對應識別碼,把消息轉發過去;裝置收到後再遞交給對應的 App,依設定彈出通知。

可變與不可變型別

以 NSArray 與 NSMutableArray 為例:前者初始化後記憶體配置固定、不可變;後者可以隨時增刪元素,必要時動態申請新的記憶體空間。

frame 與 bounds

frame 是該 view 在父 view 座標系統中的位置與大小;bounds 是該 view 在自身座標系統中的位置與大小。兩者的參照點不同,這是旋轉與滾動相關計算最容易出錯的地方。

CALayer 與 UIView 的差異

最大的差別是:圖層不會直接渲染到螢幕上。UIView 是 iOS 介面元素的基礎,所有控制項都繼承自它,其底層完全由 CoreAnimation 實作,真正的繪圖部分交由 CALayer 管理。可以說 UIView 更像是一個 CALayer 的管理者——一個 view 上可以有多個 layer,每個 layer 顯示不同內容,藉此增強呈現能力。

方法(method)與選擇器(selector)

selector 是一個方法的名稱,method 則是一個包含名稱與實作的組合體。此外,SEL 型別代表方法名稱;IMP 定義為 id (*IMP)(id, SEL, ...),是一個指向函式的指標,指向的函式包含 self、被呼叫的 SEL 以及其他參數——說白了,IMP 就是方法的實作。

id 與 nil

id 與 void * 並不完全等價。id 指向 struct objc_object,基本上表示「任何繼承自 NSObject 的物件」。由於 id 本身就是指標,使用時不需要加星號:id foo = nil; 宣告一個指向任意 NSObject 子類的指標;而 id *foo = nil; 宣告的是指向指標的指標。nil 等同 C 的 NULL,表示一個指向空的 Objective-C 物件;首字母大寫的 Nil 則是宣告一個指向空類別(Class)的指標。

類別的继承體系:UIControl 之上是什麼

UIButton 的父類別是 UIControl,UIControl 的父類別是 UIView,UIView 的父類別是 UIResponder。

ViewController 的生命週期方法

viewDidLoad 在 view 從 nib 檔案初始化後呼叫;loadView 在 controller 的 view 為 nil 時呼叫,也就是以程式碼實作 view 時該方法被使用。view controller 預設會註冊記憶體警告通知,當任何沒用到的 view 需要被清掉時,viewDidUnload 會被呼叫——在這裡實作把 retain 的 view 釋放。但若是 retain 的 IBOutlet 屬性,就不要在這裡 release,因為 IBOutlet 會自行負責。

懶載(lazy loading)

只在真正用到的時候才初始化的模式,也可以理解為延遲載入。最典型的例子就是 tableView 中的圖片載入:一個負責延遲載入以避免記憶體過高,一個負責非同步載入以避免執行緒堵塞。

回應鏈(responder chain)

事件回應鏈,涵蓋點擊事件、畫面刷新事件等,在視圖堆疊中由上而下或由下而上傳遞,負責點事件的派發、傳遞與處理。

static 的用途

  1. 函式內的 static 變數,作用域限於該函式,但記憶體只配置一次,因此下次呼叫時仍保有上次的值(有別於 auto 變數)。
  2. 模組內的 static 全域變數可被該模組內所有函式存取,但模組外的函式無法存取。
  3. 模組內的 static 函式只能被同一模組內的其他函式呼叫,使用範圍被限制在宣告它的模組內。
  4. 類別中的 static 成員變數屬於整個類別,所有物件共用同一份。
  5. 類別中的 static 成員函式同樣屬於整個類別,不接收 this 指標,因此只能存取 static 成員變數。

此外,static 也能用來限制變數作用域或指定變數的儲存區。

Objective-C 的優缺點

優點:Categories、Posing、動態識別、指標計算、彈性訊息傳遞、語法不像 C++ 那樣過度複雜、可與 C++ 混合編程。

缺點:不支援命名空間、不支援運算子重載、不支援多重繼承;由於使用動態執行期型別,所有方法都是函式呼叫,許多編譯時優化(如 inline)用不上,效能相對吃虞。

五、C/C++ 基礎

strcpy、memcpy、sprintf 的使用風險

  • strcpy(char *dst, const char *src):把 src 起的字串複製到 dst 起的記憶體,以 '\0' 結束。由於複製長度不受控,非常容易出錯。
  • memcpy(char *dst, const char *src, unsigned int len):複製長度 len 的記憶體,長度可控,但存在記憶體重疊問題。
  • sprintf:格式化函式,把資料依特定格式寫入字串緩衝區。格式化後的長度不可控,可能超出緩衝區大小而造成溢位。

寫一個「標準」的 strcpy

char *strcpy(char *strDest, const char *strSrc) {
    assert((strDest != NULL) && (strSrc != NULL));
    char *address = strDest;
    while ((*strDest++ = *strSrc++) != '\0');
    return address;
}

一個完善的實作需要具備:源參數加 const 表明它是輸入參數;對來源與目的位址做非 NULL 斷言;回傳目的位址以支援鏈式操作。同理,strlen 也應該對輸入參數加 const 並做斷言,而且要注意它不包含字串末尾的 '\0'。

數組越界的常見陷阱

// 錯誤:str1 需要 11 位元組(含 '\0'),string 只有 10
void test1() { char string[10]; char *str1 = "0123456789"; strcpy(string, str1); }

// 錯誤:str1 未以 '\0' 結束就 strcpy,複製長度不確定
// 錯誤:strlen(str1) <= 10 應改為 < 10,因為 strlen 不計 '\0'
void test3(char *str1) { char string[10]; if (strlen(str1) <= 10) { strcpy(string, str1); } }

指標宣告讀法

int a;              // 一個整數
int *a;             // 指向整數的指標
int **a;            // 指向指標的指標
int a[10];          // 含 10 個整數的陣列
int *a[10];         // 含 10 個指向整數之指標的陣列
int (*a)[10];       // 指向「含 10 個整數之陣列」的指標
int (*a)(int);      // 指向一個「接受 int、回傳 int」之函式的指標
int (*a[10])(int);  // 含 10 個上述函式指標的陣列

指標與位址、陣列名的關係

指標意味著存在一個指標變數,它的值是一個位址,而指標變數本身也存在於一段固定長度的記憶體中;位址這個概念本身並不代表有任何變數存在。位址表示記憶體中的一個位置點,本身沒有大小概念,指向變數的大小取決於位址後存放的型別。

指標與陣列名的值都是位址,但前者可以移動,後者不行。陣列名的本質是:它指代一種資料結構(如 char[10]);它可以轉換為指向該實體的指標,且是一個指標常量,不能做增減或修改;但當它作為函式形參時,就淪為普通的指標——此時 sizeof(str) 得到的是指標大小(32 位平台下為 4),而不是陣列總大小。

如何避免指標越界與野指標

  1. 必須讓指標指向一個有效的記憶體位址。
  2. 防止陣列越界。
  3. 防止向一塊記憶體複製過多內容。
  4. 防止使用空指標。
  5. 防止修改 const 修飾的指標。
  6. 防止修改指向靜態儲存區的內容。
  7. 防止兩次釋放同一個指標。
  8. 防止使用野指標。

堆與棧的差異

  • 管理方式:棧由編譯器自動管理,無需手動控制;堆的釋放由開發者負責,容易產生記憶體洩漏。
  • 申請大小:棧是向低位址擴展的連續記憶體區域,頂端位址與最大容量由系統預先決定(Windows 下通常是 1~2 MB),超出剩餘空間就會 overflow,因此可用空間較小。堆是向高位址擴展的非連續區域,系統以鏈表維護空閒位址,大小受限於可用的虛擬記憶體,因此更靈活也更大。
  • 碎片問題:堆頻繁配置/釋放會造成空間不連續,產生大量碎片而降低效率;棧是後進先出、一進一出一一對應,不存在這個問題。
  • 配置方式:堆都是動態配置。棧有靜態配置(由編譯器完成,如區域變數)與動態配置(由 alloca 進行,但釋放仍由編譯器負責)。
  • 配置效率:棧由機器系統提供支援,有專用暫存器存放位址、有專用指令執行壓入彈出,效率較高;堆由函式庫提供,機制複雜得多。

結構體與等位元組的大小計算

union 的大小取決於占用空間最大的成員。但對界(alignment)會改變這個結論:

union u2 { char a[13]; int b; };   // sizeof = 16
union u3 { char a[13]; char b; };  // sizeof = 13

u2 中存在 int 成員,使它的對界變成 4,因此大小必須落在 4 的倍數上,於是 13 被補到 16。

結構體同理:

struct s1 { char a; double b; int c; char d; };   // sizeof = 24
struct s2 { char a; char b; int c; double d; };   // sizeof = 16

計算方式是「元素擺放法」:先依最大成員型別決定整體對界(這裡都是 double,對界 8),再逐一擺放每個元素到離目前位置最近的對界位址,最後把總大小補成對界的倍數。s1 因為 double 被塞在中間,產生較多補白;s2 把小型別集中在前面,空間利用就緊湊許多。這也是實務上調整結構體成員順序以省記憶體的依據。

大端與小端

Little-endian 的 CPU 把運算元從低位元組到高位元組存放,Big-endian 則相反。以 0x12345678 存在位址 0x4000 起為例:小端是 78 56 34 12,大端是 12 34 56 78。Intel 的處理器採用小端,IBM 與 Freescale 的 PowerPC 採用大端,而某些周邊設計也可能採用與 CPU 不同的順序,因此同一個系統中兩種模式並存並不罕見。

以下函式可以判斷 CPU 的位元組序:

int checkCPU() {
    union w { int a; char b; } c;
    c.a = 1;
    return (c.b == 1);   // 小端回傳 1,大端回傳 0
}

原理是等位元組的存放順序由低位址開始:小端時 c.a = 1 的記憶體是 01 00 00 00,因此 c.b 取到 0x01;大端時是 00 00 00 01,c.b 取到 0x00。

宏定義的兩個陷阱

#define MIN(A, B) ((A) <= (B) ? (A) : (B))
  1. 括號:宏中的「參數」與整個宏都必須用括號包好,否則運算優先順序會出問題。少了括號的版本應視為錯誤。
  2. 副作用:MIN(*p++, b) 展開後會變成 ((*p++) <= (b) ? (*p++) : (*p++)),指標 p 會被自增多次。

另外,宏定義結尾多了一個分號,也顯示撰寫者對宏的概念模糊。

標準標頭檔的結構

#ifndef __INCvxWorksh
#define __INCvxWorksh

#ifdef __cplusplus
extern "C" {
#endif

/* ... */

#ifdef __cplusplus
}
#endif

#endif /* __INCvxWorksh */

#ifndef / #define / #endif 的作用是避免被重複引用。而 extern "C" 則是為了 C++ 與 C 混合編程:C++ 支援函式重載,編譯後在 symbol 庫中的名稱會帶上參數型別資訊(如 _foo_int_int),C 編譯器則產生 _foo。加上 extern "C" 後,編譯器會改用 C 的命名方式,C 程式碼才能順利連結 C++ 實作的函式。

其他常見 C 題

寫出與「零值」比較的 if 敘述,不同型別該有不同寫法,目的是讓程式碼清楚表達意圖:

BOOL 型:if (!var)
int 型: if (var == 0)
指標:   if (var == NULL)
float:  const float EPSINON = 0.00001;
         if ((x >= -EPSINON) && (x <= EPSINON))

浮點數並不精確,不可用 == 或 != 與數字直接比較,應改寫成 >= 或 <= 的形式。

另外,「函式不能宣告為虛函式」的答案是 constructor(建構子);冒泡排序的時間複雜度是 O(n²);for( ;1 ;) 等同 while(1);do...while 是「先執行一遍再判斷」,while...do 是「先判斷再循環」;switch 的參數不能是實數型別。

全域變數與區域變數在記憶體中的確有差別:全域變數存放在靜態資料區,區域變數則在堆疊上。區域變數可以與全域變數同名,函式內會優先使用區域變數,要存取全域變數需加上 ::。要引用一個已定義的全域變數,可以用 include 標頭檔或 extern;兩者的差別在於錯誤發現的時機——標頭檔方式在編譯期就報錯,extern 方式則要到連結期才報錯。

六、網路協定基礎

HTTP 狀態碼

  • 1xx:請求已接受,繼續處理。
  • 2xx:成功。
  • 3xx:重定向(如 302)。
  • 4xx:請求連結錯誤或找不到資源。
  • 5xx:伺服器錯誤。

HTTP 的主要特點

  1. 支援客戶端/伺服器模式。
  2. 簡單快速:客戶端只需傳送請求方法與路徑,常用方法有 GET、HEAD、POST,因此伺服器程式規模小、通訊速度快。
  3. 靈活:允許傳輸任意型別的資料物件,型別由 Content-Type 標記。
  4. 無連線:每次連線只處理一個請求,伺服器回應後即斷開,可節省傳輸時間。
  5. 無狀態:協議對事務處理沒有記憶能力。若後續處理需要前面的資訊,就必須重傳,這可能增加每次連線的資料量;但反過來,當伺服器不需要先前資訊時,回應就更快。

URL 的格式

https://host[":"port][abs_path]

http 表示以 HTTP 協定定位網路資源;host 是合法的網域名稱或 IP;port 為連接埠,省略時使用預設的 80;abs_path 是請求資源的 URI,若未提供則必須以 "/" 形式給出(通常由瀏覽器自動補上)。

HTTP Keep-Alive

HTTP 是典型的請求/回應模式。在舊版本中,每個請求都要新建一條客戶端到伺服器的連線,用完即丟——簡單易實作,但效率低。Keep-Alive 就是為了解決這個問題:讓連線持續有效,後續請求直接複用,避免反覆建立連線。

Keep-Alive: timeout=5, max=100

timeout 是過期時間(對應 httpd.conf 中的 KeepAliveTimeout),max 是最多允許的請求數;在 timeout 之內每來一個新請求,max 就遞減,減到 0 就強制斷線。

版本差異值得注意:HTTP/1.0 並沒有官方標準規範 Keep-Alive,需要客戶端在請求標頭加上 Connection: Keep-Alive,伺服器回應時也帶上同樣欄位,連線才會保持。HTTP/1.1 則預設所有連線都保持,除非明確標明 Connection: Close——這也是為什麼 Connection: Keep-Alive 在 1.1 中變得沒有意義。

另外要牢記 Keep-Alive 不可靠:HTTP 是無狀態協議,Keep-Alive 並未改變這點;它也不保證連線一定還活著,唯一保證的是連線關閉時你會收到通知。因此程式不應依賴它的保持連線特性。

對於負擔較重的網站,Keep-Alive 反而是雙面刃:雖然省去重建連線的成本,但暫停期間本可釋放的資源仍被占用;當 Web 伺服器與應用伺服器跑在同一台機器上時,這個影響尤其明顯。此外,HTTP/1.1 規定 POST 訊息本文之後不能有任何字元,但部分瀏覽器會自動補上 CRLF,實務上的解法是在 POST 請求中避免使用 Keep-Alive,或依賴伺服器自動忽略該字元(多數伺服器會這麼做,但未經測試無法確定)。

TCP 與 UDP

TCP 是面向連線的協議,提供可靠的位元組流服務。雙方交換資料前必須先建立連線,並透過超時重送、丟棄重複資料、檢驗資料、流量控制等機制保證資料能從一端抵達另一端。UDP 則是簡單的無連線資料報協議,不保證送達,但因為不必建連、沒有重送機制,傳輸速度很快,適合一次只傳少量資料、對可靠性要求不高的場景。

TCP 建連需要三次握手:

  1. 客戶端送出一個 SYN 包(syn=j)給伺服器,進入 SYN_SEND 狀態等待確認。
  2. 伺服器收到後回覆 ACK(ack=j+1)並同時送出 SYN(syn=k),也就是 SYN+ACK 包,此時進入 SYN_RECV 狀態。
  3. 客戶端再送出 ACK(ack=k+1)確認,之後雙方進入 ESTABLISHED 狀態,三次握手完成。

握手過程中的封包不攜帶資料,三次握手結束後才正式傳輸。理想狀態下,TCP 連線會一直保持到其中一方主動關閉;斷開時雙方都可以發起請求,但需要經過四次交互才能確定關閉。

Socket 與 HTTP 的差異

你瀏覽的網頁都是以 https:// 開頭、透過 HTTP 協定傳輸的,而 HTTP 是架在 socket 之上的。Socket 並不是協定,而是一組完成 TCP/UDP 編程的介面(API)——它是對 TCP/IP 協定的封裝,讓程式設計師能更方便地使用協定堆疊。可以這樣類比:HTTP 是轎車,提供資料封裝與呈現的具體形式;Socket 是引擎,提供網路通訊的能力。

分層上看:TCP 屬於傳輸層,主要解決資料如何在網路中傳輸;IP 屬於網路層;HTTP 屬於應用層,主要解決如何包裝資料。

連線特性上:HTTP 連線就是所謂的短連線,客戶端送一次請求、伺服器回應後連線即斷;socket 連線則是長連線,理論上建立後不會主動斷開。但因為伺服器或客戶端宕機、網路故障,或長時間無資料傳輸而被防火牆釋放資源等原因,連線仍可能中斷,所以 socket 長連線需要自行設計心跳訊息來維持(格式由開發者定義)。

建立 Socket 連線的三個步驟

  1. 伺服器監聽:伺服器端 socket 不定位具體客戶端,而是處於等待連線狀態,即時監控網路狀態。
  2. 客戶端請求:客戶端 socket 提出連線請求,必須先描述目標伺服器 socket 的位址與連接埠。
  3. 連線確認:伺服器 socket 監聽到請求後回應,建立新執行緒並把伺服器 socket 的描述回傳給客戶端;客戶端確認後雙方正式建立連線,而伺服器 socket 繼續監聽其他請求。

XML 與 HTML 的差異

XML 是可擴展標記語言,用於標記電子文件使其具結構性,可標記資料、定義資料型別,是一種允許使用者自訂標記語言的源語言。與 HTML 的設計差異在於:XML 的核心是資料,重點在內容;HTML 則是為了顯示資料,重點在外觀。語法上,HTML 的標記不一定要成對出現、不區分大小寫;XML 則要求所有標記必須成對出現,且大小寫敏感。

相較於資料庫,XML 僅是儲存資料,缺乏索引、排序、查找、參照一致性等能力;但正因為簡單易讀寫,它很快成為資料交換的共通語言。XML 也去掉了 SGML 那些令人頭疼的隨意語法,改為:所有起始標籤都必須有結束標籤;可使用自封閉的簡化語法;標籤必須正確嵌套(像左右括號一樣,沒關閉內部括號前不能關閉外部);所有屬性都必須有值,且值必須用雙引號包住。

ASIDownloadCache 設定下載快取

[ASIHTTPRequest setDefaultCache:[ASIDownloadCache sharedCache]];

它會快取 GET 請求的成功回應(必須是 200)。設定快取策略後,所有請求都會自動被快取。若只想讓某次請求使用快取:

ASIHTTPRequest *request = [ASIHTTPRequest requestWithURL:url];
[request setDownloadCache:[ASIDownloadCache sharedCache]];

儲存策略有兩種:ASICacheForSessionDurationCacheStoragePolicy(預設,基於 session 的儲存,下次運行或呼叫 [ASIHTTPRequest clearSession] 時失效)與 ASICachePermanentlyCacheStoragePolicy(永久保存在本地)。

七、面試題精選補充

進程與線程的差別

進程是作業系統進行資源配置與調度的一個獨立單位,擁有自己的虛擬位址空間;線程是進程中的一個執行實體,是 CPU 調度與分派的基本單位。主要差異有四點:

  1. 調度:線程作為調度與分配的基本單位,進程作為擁有資源的單位。
  2. 並發性:不僅進程之間可以並發,同一個進程的多個線程之間也可以並發。
  3. 擁有資源:進程是擁有資源的獨立單位;線程本身幾乎不擁有系統資源(只有程式計次器、一組暫存器與堆疊等必要資源),但可以存取所屬進程的全部資源。
  4. 系統開銷:建立或撤銷進程時系統要配置與回收資源,開銷明顯大於建立或撤銷線程。

因為線程更小、幾乎不擁有系統資源,調度開銷小得多,能更有效率地提高系統內多程序的並發程度。但這也帶來權衡:一個線程掛掉就等於整個進程掛掉,所以多進程的程式通常比多線程更健壯;而進程切換的資源消耗較大、效率較差。若需求是「同時進行且必須共享某些變數」,就只能用線程。此外,線程適合在 SMP 機器上運行,進程則可以跨機器遷移。

堆與棧上的指標

指標所指向的那塊記憶體在哪裡配置,就稱為堆上的指標或堆疊上的指標。堆上的指標可以保存在全域資料結構中,讓不同函式存取同一塊記憶體;堆疊上的指標則在函式退出後就無法再存取。

「釋放指標」其實包含兩件事:釋放該指標指向的記憶體(只有堆上的記憶體需要手動釋放),以及把指標重新指向 NULL。

指標的其他常見問法

  • 資料結構中的指標:就是指向一塊記憶體的位址,透過指標傳遞可實現複雜的記憶體存取。
  • 函式指標:指向一段函式的入口位址。
  • 指標作為函式參數:例如把一個複雜資料結構的指標當成函式變數傳入,可避免整個資料型別的壓疊出疊操作,提高效率。注意指標本身不可變,但它指向的資料結構可以改變。
  • 指向指標的指標:指標指向的變數本身是一個指標,其內容是一個位址,長度同樣是一個指標的大小。

引用與指標的差別

  1. 引用必須被初始化,指標不必。
  2. 引用初始化後不能再改變,指標可以改指向其他物件。
  3. 不存在指向空值的引用,但存在指向空值的指標。

其他零散題目

  • 即時系統的基本特性:在指定期間內完成指定任務,即時性與可靠性。
  • 平衡二叉樹:左右子樹都是平衡二叉樹,且左右子樹深度差的絕對值不大於 1。
  • 堆疊溢出的常見原因:沒有回收不再使用的資源;也可能是遞迴過深或區域變數過大。
  • IP 位址的組成:網路號與主機號兩部分,但要與子網路遮罩按位元 AND 之後才能區分哪些是網路位、哪些是主機位。
  • 實體位址與 IP 位址的轉換:使用 ARP(Address Resolution Protocol,位址解析協定)。
  • Internet 的協定與分層:TCP/IP,分為應用層、傳輸層、網路層、資料連結層、物理層。
  • Windows 下如何只允許程式運行一個實例:可用記憶體對映、全域 mutex(互斥變數)、FindWindow 查找視窗句柄,或把標誌寫入檔案/登錄檔、使用共享記憶體。
  • 如何攔截鍵盤響應,把所有 'a' 變成 'b':使用鍵盤鉤子 SetWindowsHookEx。
  • 儲存程序:一堆 SQL 的集合,可以建立相當複雜的查詢。因為會先編譯再運行,第一次之後再執行同一支程序的速度會比逐句執行 SQL 快很多。
  • 如何找出帶環單鏈表環的入口:用兩個指標,一個每次走一步、一個每次走兩步,兩者相遇的位置附近的規律可用來推定位於環的入口。
  • 類別工廠方法:把配置與初始化合併為一個步驟,回傳配置好的物件並自動釋放。除了方便,它還能在初始化過程中提供物件配置的資訊;另一個用途是實作單例(如 NSWorkspace)——相較於 init 系列方法,工廠方法可以避免為可能用不到的物件盲目配置記憶體。
  • 單例物件:Foundation 與 Application Kit 中有些類別只允許建立單例,例如 NSFileManager 與 NSWorkspace,它們以進程為單位提供唯一實例,充當控制中心的角色。若某個類別在概念上只有一個實例,就該做成單例。
  • 自動釋放池:當你對一個物件送出 autorelease 訊息時,Cocoa 會把該物件的一個參照放進最新的自動釋放池。它在作用域內仍是正當物件,可以繼續接收訊息;當執行到作用域結束時,池被釋放,池中所有物件也一併被釋放。autorelease 與 release 的差別只在於引用計數遞減的時機——前者會等到物件的使用真正結束時才遞減。
  • Objective-C 的記憶體管理規則:若透過 alloc/init 或 new 建立物件,你就擁有它,需負責釋放;若複製一個物件,你也擁有複製出來的物件;若 retain 一個物件,你部分擁有它,不用時要釋放。反過來,若你只是從其他物件處收到一個物件,通常並不擁有它,也不該釋放(少數例外在文件中明確標註)。
  • 記憶體洩漏檢查:在 Xcode 的 Product 選單中執行 Analyze(Run Static Analyzer)即可靜態掃描可疑問題。
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved