這份筆記把 iOS/Objective-C 開發與面試中最常被問到的問題做了歸納,分成記憶體管理、多執行緒、第三方套件原理、語言特性、C 語言基礎、網路協定與經典面試題七大主題,方便逐塊複習。
__block 在 ARC 與 MRC 下都能使用,除了物件之外,也能修飾基本資料型別。__weak 只能在 ARC 下使用,而且只能修飾物件(如 NSString),無法修飾基本型別(如 int)。__block 修飾的變數可以在 block 內部被重新賦值,__weak 則不行。舉例來說,NSString *newPt = [pt copy]; 會在堆上配置一段新記憶體存放 "abc"(假設位址 0x1122),同時在堆疊上為 newPt 配置空間(假設位址 0xaacc),內容是 0x1122。此時 retainCount 增加 1,交給 newPt 管理那段記憶體。
NSString *newPt = [pt assign]; 這種寫法下 newPt 和 pt 完全相同,位址都是 0xaaaa、內容都是 0x1111,newPt 只是 pt 的別名;對其中一個的操作等同於對另一個操作,因此 retainCount 不需增加。NSString *newPt = [pt retain]; 此時 newPt 的位址不再是 0xaaaa(可能是 0xaabb),但內容仍為 0x1111。newPt 與 pt 都能管理 "abc" 所在的記憶體,因此 retainCount 需要加 1。@synthesize,編譯器也會只解析出 getter。@implementation 中實作(或交由 @synthesize 解析)。ARC 會在編譯階段自動把 retain/release 插入程式碼中,原本需要手動維護的引用計數改由編譯器完成。這項機制自 iOS 5 與 Mac OS X 10.7 起導入,搭配 Xcode 4.2 之後即可使用。
@synthesize abc = _abc; 時,系統會自動幫你宣告一個 _abc 實例變數。淺複製只複製指向物件的指標,不複製參考物件本身;深複製則會複製參考物件本身。也就是說,若有 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 的變數,代表它可能在程式意料之外的時機被改變,因此編譯器不能假設它的值,每次使用都必須重新讀取,而不能沿用暫存器中的副本。典型場景包括:平行裝置的硬體暫存器(如狀態暫存器)、中斷服務常式會存取的非常自動變數,以及多執行緒應用中被多個任務共享的變數。
兩個常見延伸問題:變數可以同時是 const 與 volatile 嗎?可以,例如唯讀的狀態暫存器——它可能被硬體改變(volatile),但程式不應去修改它(const)。指標可以是 volatile 嗎?可以,例如中斷常式修改一個指向 buffer 的指標時。
為了避免介面在處理耗時操作(網路請求、檔案 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_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_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(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 是存放 NSOperation 的集合類,操作與操作佇列的關係,大致可以類比 Java 中的執行緒與執行緒池,同樣用來處理 iOS 的多執行緒問題。要注意的是,它雖然叫「佇列」,放入的操作卻不是嚴格的先進先出——因為兩個操作提交的時間間隔很近時,執行緒池中的哪條執行緒先啟動並不確定。可以把它想像成銀行的取票與叫號系統:先取票的人不一定先辦完。實務上,它的主要價值在於協助你把多執行緒編程寫得更乾淨。
主要原因通常是從快取或本地讀取圖片交給 UIImage 時所花的時間。解法是把讀取與解碼放到子執行緒:
NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:app.icon]];
UIImage *image = [UIImage imageWithData:imgData];
而把 image 實際賦值給 view 的動作,則要回到主執行緒。核心原則是:子執行緒不能更新 UI,所有 UI 更新都必須在主執行緒進行。
在子執行緒加入 NSTimer 時,必須手動為該執行緒的 RunLoop 添加 timer,否則計時器不會循環觸發。
若單例裡有一個 NSMutableArray,又可能被多個地方同時遍歷與修改,建議改用原子屬性並搭配 strong,同時自行實作遍歷與修改的方法,並在其中加上 Lock/Unlock。
__weak ViewController *weakSelf = self;
在 GCD 的區塊中使用 __weak,可以避免區塊強持有 self 所導致的記憶體無法釋放。
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 都不會破壞這個唯一性。
呼叫入口 setImageWithURL:placeholderImage:options: 後,會先把 placeholderImage 顯示出來,接著由 SDWebImageManager 依 URL 開始處理圖片:
SDWebImageManager-downloadWithURL:delegate:options:userInfo:,交給 SDImageCache 透過 queryDiskCacheForKey:delegate:userInfo: 查詢快取。imageCache:didFindImage:forKey:userInfo: 給 SDWebImageManager。webImageManager:didFinishWithImage: 給 UIImageView+WebCache 等前端,完成顯示。notifyDelegate:。imageCache:didFindImage:forKey:userInfo:,進而顯示圖片。imageCache:didNotFindImageForKey:userInfo:,開始下載。connection:didReceiveData: 中利用 ImageIO 做出依下載進度遞增的載入效果。connectionDidFinishLoading: 把資料交給 SDWebImageDecoder 解碼。解碼在一個 NSOperationQueue 中完成,不會拖慢主執行緒的 UI。若需要對圖片做二次處理,放在這裡效率最好。notifyDelegateOnMainThreadWithInfo:,透過 imageDecoder:didFinishDecodingImage:userInfo: 回呼 SDWebImageDownloader。imageDownloader:didFinishWithImage: 回呼 SDWebImageManager,告知下載完成。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: 的各種變體,就足以獲得相當不錯的圖片快取能力。
@synthesize:若開發者沒有自行實作,編譯器會自動生成符合屬性宣告的 getter/setter。@dynamic:告訴編譯器,屬性的存取方法由開發者自行實作,不要自動生成。唯讀屬性需自行提供 getter,讀寫屬性則需同時提供 getter 與 setter。三個主要作用:把類別的實作分散到多個檔案或框架中;為私有方法建立前向引用;向物件加入非正式協議。
兩個主要限制:無法為類別新增實例變數(類別沒有位置容納它們,實務上可用字典物件繞過);名稱衝突——若類別中的方法與原始類別同名,類別具有更高優先級,會完全取代原始方法且無法再呼叫回去。
category 可以在不獲悉、不改變原始程式碼的前提下增加新方法,只能新增、不能刪除或修改;一旦與原有方法同名,category 會覆蓋原方法。而繼承則可以新增、修改、刪除方法,也能新增屬性。
兩者的差別在於 extension 可以新增屬性,而且它宣告的方法必須被實作。可以把 extension 理解為一個私有的 category。
OC 的 protocol 有 formal 與 informal 兩層含義,前者等同 Java 的介面;informal protocol 中的方法屬於設計模式範疇,不強制實作,但一旦實作就會改變類別的行為。現在 protocol 已用 @required 與 @optional 兩個修飾詞把兩者統一規範起來。
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];
}
}
目標是動作訊息的接收者。一個控制項(更常見的是它的 cell)以插座變數(outlet)的形式持有動作訊息的目標。動作則是控制項送給目標的訊息;從目標的角度看,它是為了回應動作而實作的方法。App 需要某種機制來把事件與指令做翻譯,這就是 target-action 機制。
動態綁定把「要呼叫哪個方法」的決定延後到執行期。編譯時,方法呼叫並未與程式碼綁定,只有訊息真正送出後才確定被呼叫的程式碼。執行環境會透過接收者的 isa 指標找到物件的類別,再據此找出方法。你不需要在 Objective-C 程式碼中做任何額外工作,就能自動享受動態綁定的好處。
所謂「OC 是執行期語言」,重點在於多態:把資料型別的確定從編譯時推遲到執行時。不同物件以自己的方式回應同一個訊息,就是多態。
delegate 針對一對一關係,且接收者可以把值回傳給發送者;notification 則可對一對一、一對多、甚至沒有接收者,且接收者無法回傳值。因此:當發送者需要接收者的某項功能回饋值時用 delegate;只是要通知多個物件某個事件已發生時用 notification。
兩者更本質的差異是控制鏈(has-a):協議存在明確的控制關係,通知沒有。代理側重「一一對應的委託關係」,而通知只負責廣播,不关心有多少人收到並處理。
代理的目的是改變或傳遞控制鏈,讓一個類別能在特定時機通知其他類別,而不必持有那些類別的指標,藉此降低框架複雜度;它有點類似 Java 中的回呼監聽機制。
推送通知則是伺服器端主動 push 的一種技術,與一般客戶端主動 pull 的模式相反。以 APNS 為例,整個流程可分三階段:Provider(你的服務器)把要發送的消息與目標裝置識別碼打包送給 APNS;APNS 在已註冊的裝置清單中查找對應識別碼,把消息轉發過去;裝置收到後再遞交給對應的 App,依設定彈出通知。
以 NSArray 與 NSMutableArray 為例:前者初始化後記憶體配置固定、不可變;後者可以隨時增刪元素,必要時動態申請新的記憶體空間。
frame 是該 view 在父 view 座標系統中的位置與大小;bounds 是該 view 在自身座標系統中的位置與大小。兩者的參照點不同,這是旋轉與滾動相關計算最容易出錯的地方。
最大的差別是:圖層不會直接渲染到螢幕上。UIView 是 iOS 介面元素的基礎,所有控制項都繼承自它,其底層完全由 CoreAnimation 實作,真正的繪圖部分交由 CALayer 管理。可以說 UIView 更像是一個 CALayer 的管理者——一個 view 上可以有多個 layer,每個 layer 顯示不同內容,藉此增強呈現能力。
selector 是一個方法的名稱,method 則是一個包含名稱與實作的組合體。此外,SEL 型別代表方法名稱;IMP 定義為 id (*IMP)(id, SEL, ...),是一個指向函式的指標,指向的函式包含 self、被呼叫的 SEL 以及其他參數——說白了,IMP 就是方法的實作。
id 與 void * 並不完全等價。id 指向 struct objc_object,基本上表示「任何繼承自 NSObject 的物件」。由於 id 本身就是指標,使用時不需要加星號:id foo = nil; 宣告一個指向任意 NSObject 子類的指標;而 id *foo = nil; 宣告的是指向指標的指標。nil 等同 C 的 NULL,表示一個指向空的 Objective-C 物件;首字母大寫的 Nil 則是宣告一個指向空類別(Class)的指標。
UIButton 的父類別是 UIControl,UIControl 的父類別是 UIView,UIView 的父類別是 UIResponder。
viewDidLoad 在 view 從 nib 檔案初始化後呼叫;loadView 在 controller 的 view 為 nil 時呼叫,也就是以程式碼實作 view 時該方法被使用。view controller 預設會註冊記憶體警告通知,當任何沒用到的 view 需要被清掉時,viewDidUnload 會被呼叫——在這裡實作把 retain 的 view 釋放。但若是 retain 的 IBOutlet 屬性,就不要在這裡 release,因為 IBOutlet 會自行負責。
只在真正用到的時候才初始化的模式,也可以理解為延遲載入。最典型的例子就是 tableView 中的圖片載入:一個負責延遲載入以避免記憶體過高,一個負責非同步載入以避免執行緒堵塞。
事件回應鏈,涵蓋點擊事件、畫面刷新事件等,在視圖堆疊中由上而下或由下而上傳遞,負責點事件的派發、傳遞與處理。
此外,static 也能用來限制變數作用域或指定變數的儲存區。
優點:Categories、Posing、動態識別、指標計算、彈性訊息傳遞、語法不像 C++ 那樣過度複雜、可與 C++ 混合編程。
缺點:不支援命名空間、不支援運算子重載、不支援多重繼承;由於使用動態執行期型別,所有方法都是函式呼叫,許多編譯時優化(如 inline)用不上,效能相對吃虞。
strcpy(char *dst, const char *src):把 src 起的字串複製到 dst 起的記憶體,以 '\0' 結束。由於複製長度不受控,非常容易出錯。memcpy(char *dst, const char *src, unsigned int len):複製長度 len 的記憶體,長度可控,但存在記憶體重疊問題。sprintf:格式化函式,把資料依特定格式寫入字串緩衝區。格式化後的長度不可控,可能超出緩衝區大小而造成溢位。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),而不是陣列總大小。
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))
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++ 實作的函式。
寫出與「零值」比較的 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 方式則要到連結期才報錯。
https://host[":"port][abs_path]
http 表示以 HTTP 協定定位網路資源;host 是合法的網域名稱或 IP;port 為連接埠,省略時使用預設的 80;abs_path 是請求資源的 URI,若未提供則必須以 "/" 形式給出(通常由瀏覽器自動補上)。
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 建連需要三次握手:
握手過程中的封包不攜帶資料,三次握手結束後才正式傳輸。理想狀態下,TCP 連線會一直保持到其中一方主動關閉;斷開時雙方都可以發起請求,但需要經過四次交互才能確定關閉。
你瀏覽的網頁都是以 https:// 開頭、透過 HTTP 協定傳輸的,而 HTTP 是架在 socket 之上的。Socket 並不是協定,而是一組完成 TCP/UDP 編程的介面(API)——它是對 TCP/IP 協定的封裝,讓程式設計師能更方便地使用協定堆疊。可以這樣類比:HTTP 是轎車,提供資料封裝與呈現的具體形式;Socket 是引擎,提供網路通訊的能力。
分層上看:TCP 屬於傳輸層,主要解決資料如何在網路中傳輸;IP 屬於網路層;HTTP 屬於應用層,主要解決如何包裝資料。
連線特性上:HTTP 連線就是所謂的短連線,客戶端送一次請求、伺服器回應後連線即斷;socket 連線則是長連線,理論上建立後不會主動斷開。但因為伺服器或客戶端宕機、網路故障,或長時間無資料傳輸而被防火牆釋放資源等原因,連線仍可能中斷,所以 socket 長連線需要自行設計心跳訊息來維持(格式由開發者定義)。
XML 是可擴展標記語言,用於標記電子文件使其具結構性,可標記資料、定義資料型別,是一種允許使用者自訂標記語言的源語言。與 HTML 的設計差異在於:XML 的核心是資料,重點在內容;HTML 則是為了顯示資料,重點在外觀。語法上,HTML 的標記不一定要成對出現、不區分大小寫;XML 則要求所有標記必須成對出現,且大小寫敏感。
相較於資料庫,XML 僅是儲存資料,缺乏索引、排序、查找、參照一致性等能力;但正因為簡單易讀寫,它很快成為資料交換的共通語言。XML 也去掉了 SGML 那些令人頭疼的隨意語法,改為:所有起始標籤都必須有結束標籤;可使用自封閉的簡化語法;標籤必須正確嵌套(像左右括號一樣,沒關閉內部括號前不能關閉外部);所有屬性都必須有值,且值必須用雙引號包住。
[ASIHTTPRequest setDefaultCache:[ASIDownloadCache sharedCache]];
它會快取 GET 請求的成功回應(必須是 200)。設定快取策略後,所有請求都會自動被快取。若只想讓某次請求使用快取:
ASIHTTPRequest *request = [ASIHTTPRequest requestWithURL:url];
[request setDownloadCache:[ASIDownloadCache sharedCache]];
儲存策略有兩種:ASICacheForSessionDurationCacheStoragePolicy(預設,基於 session 的儲存,下次運行或呼叫 [ASIHTTPRequest clearSession] 時失效)與 ASICachePermanentlyCacheStoragePolicy(永久保存在本地)。
進程是作業系統進行資源配置與調度的一個獨立單位,擁有自己的虛擬位址空間;線程是進程中的一個執行實體,是 CPU 調度與分派的基本單位。主要差異有四點:
因為線程更小、幾乎不擁有系統資源,調度開銷小得多,能更有效率地提高系統內多程序的並發程度。但這也帶來權衡:一個線程掛掉就等於整個進程掛掉,所以多進程的程式通常比多線程更健壯;而進程切換的資源消耗較大、效率較差。若需求是「同時進行且必須共享某些變數」,就只能用線程。此外,線程適合在 SMP 機器上運行,進程則可以跨機器遷移。
指標所指向的那塊記憶體在哪裡配置,就稱為堆上的指標或堆疊上的指標。堆上的指標可以保存在全域資料結構中,讓不同函式存取同一塊記憶體;堆疊上的指標則在函式退出後就無法再存取。
「釋放指標」其實包含兩件事:釋放該指標指向的記憶體(只有堆上的記憶體需要手動釋放),以及把指標重新指向 NULL。