iOS開發－面試總結（九）

時間 2019-11-08

標籤 ios 開發面試總結欄目 iOS 简体版

原文原文鏈接

iOS面試指導java

一ios

通過本人最近的面試和對面試資料的一些彙總，準備記錄這些面試題，以便ios開發工程師找工做複習之用，本人但願有面試經驗的同窗能和我同時完成這個模塊，先出面試題，而後會放出答案。c++

1. 你使用過Objective-C的運行時編程（Runtime Programming）麼？若是使用過，你用它作了什麼？你還能記得你所使用的相關的頭文件或者某些方法的名稱嗎？
答案：Objecitve-C的重要特性是Runtime（運行時）,在#import <objc/runtime.h> 下能看到相關的方法，用過objc_getClass()和class_copyMethodList()獲取過私有API;使用
objective-c
Method method1 = class_getInstanceMethod(cls, sel1);
Method method2 = class_getInstanceMethod(cls, sel2);
method_exchangeImplementations(method1, method2);
代碼交換兩個方法，在寫unit test時使用到。git

2. 你實現過多線程的Core Data麼？NSPersistentStoreCoordinator，NSManagedObjectContext和NSManagedObject中的哪些須要在線程中建立或者傳遞？你是用什麼樣的策略來實現的？
答案：沒實現過多線程的CoreData(待實踐)程序員

3. Core開頭的系列的內容。是否使用過CoreAnimation和CoreGraphics。UI框架和CA，CG框架的聯繫是什麼？分別用CA和CG作過些什麼動畫或者圖像上的內容。（有須要的話還能夠涉及Quartz的一些內容）
答案：UI框架的底層有CoreAnimation，CoreAnimation的底層有CoreGraphics。
UIKit |
———— |
Core Animation |
Core Graphics |
Graphics Hardware|
使用CA作過menu菜單的展開收起（太遜了）github

4. 是否使用過CoreText或者CoreImage等？若是使用過，請談談你使用CoreText或者CoreImage的體驗。
答案：CoreText能夠解決複雜文字內容排版問題。CoreImage能夠處理圖片，爲其添加各類效果。體驗是很強大，挺複雜的。web

5. NSNotification和KVO的區別和用法是什麼？何時應該使用通知，何時應該使用KVO，它們的實現上有什麼區別嗎？若是用 protocol和delegate（或者delegate的Array）來實現相似的功能可能嗎？若是可能，會有什麼潛在的問題？若是不能，爲何？（雖然protocol和delegate這種東西面試已經面爛了…）
答案：NSNotification是通知模式在iOS的實現，KVO的全稱是鍵值觀察(Key-value observing),其是基於KVC（key-value coding）的，KVC是一個經過屬性名訪問屬性變量的機制。例如將Module層的變化，通知到多個Controller對象時，能夠使用 NSNotification；若是是隻須要觀察某個對象的某個屬性，能夠使用KVO。
對於委託模式，在設計模式中是對象適配器模式，其是delegate是指向某個對象的，這是一對一的關係，而在通知模式中，每每是一對多的關係。委託模式，從技術上能夠如今改變delegate指向的對象，但不建議這樣作，會讓人迷惑，若是一個delegate對象不斷改變，指向不一樣的對象。面試

6. 你用過NSOperationQueue麼？若是用過或者瞭解的話，你爲何要使用NSOperationQueue，實現了什麼？請描述它和GCD的區別和相似的地方（提示：能夠從二者的實現機制和適用範圍來描述）。
答案：使用NSOperationQueue用來管理子類化的NSOperation對象，控制其線程併發數目。GCD和NSOperation均可以實現對線程的管理，區別是 NSOperation和NSOperationQueue是多線程的面向對象抽象。項目中使用NSOperation的優勢是NSOperation是對線程的高度抽象，在項目中使用它，會使項目的程序結構更好，子類化 NSOperation的設計思路，是具備面向對象的優勢（複用、封裝），使得實現是多線程支持，而接口簡單，建議在複雜項目中使用。
項目中使用GCD的優勢是GCD自己很是簡單、易用，對於不復雜的多線程操做，會節省代碼量，而Block參數的使用，會是代碼更爲易讀，建議在簡單項目中使用。
更詳細的答案見個人這篇文章objective-c

7. 既然提到GCD，那麼問一下在使用GCD以及block時要注意些什麼？它們兩是一回事兒麼？block在ARC中和傳統的MRC中的行爲和用法有沒有什麼區別，須要注意些什麼？如何避免循環引用？
答案：使用block是要注意，若將block作函數參數時，須要把它放到最後，GCD是Grand Central Dispatch，是一個對線程開源類庫，而Block是閉包，是可以讀取其餘函數內部變量的函數。更詳細的答案見個人這篇文章算法

8. 您是否作過異步的網絡處理和通信方面的工做？若是有，能具體介紹一些實現策略麼？
答案：使用NSOperation發送異步網絡請求，使用NSOperationQueue管理線程數目及優先級，底層是用NSURLConnetion，詳細可見開源框架[LWConnetion](https://github.com/xunyn/LWConnetionDemo)。

9. 對於Objective-C，你認爲它最大的優勢和最大的不足是什麼？對於不足之處，如今有沒有可用的方法繞過這些不足來實現需求。若是能夠的話，你有沒有考慮或者實踐太重新實現OC的一些功能，若是有，具體會如何作？
答案：最大的優勢是它的運行時特性，不足是沒有命名空間，對於命名衝突，能夠使用長命名法或特殊前綴解決，若是是引入的第三方庫之間的命名衝突，能夠使用link命令及flag解決衝突。

10. 你實現過一個框架或者庫以供別人使用麼？若是有，請談一談構建框架或者庫時候的經驗；若是沒有，請設想和設計框架的public的API，並指出大概須要如何作、須要注意一些什麼方面，來使別人容易地使用你的框架。
答案：抽象和封裝，方便使用。首先是對問題有充分的瞭解，好比構建一個文件解壓壓縮框架，從使用者的角度出發，只需關注發送給框架一個解壓請求，框架完成複雜文件的解壓操做，而且在適當的時候通知給是哦難過者，如解壓完成、解壓出錯等。在框架內部去構建對象的關係，經過抽象讓其更爲健壯、便於更改。其次是 API的說明文檔。

11.寫一個NSString類的實現
答案：+ (id)initWithCString:(c*****t char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id) stringWithCString: (c*****t char*)nullTerminatedCString
encoding: (NSStringEncoding)encoding
{
NSString *obj;
obj = [self allocWithZone: NSDefaultMallocZone()];
obj = [obj initWithCString: nullTerminatedCString encoding: encoding];
return AUTORELEASE(obj);
}

12.static 關鍵字的做用：
答案：（1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次，
所以其值在下次調用時仍維持上次的值；
（2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問；
（3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明
它的模塊內；
（4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝；
（5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。

13.線程與進程的區別和聯繫?
答案：進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。
程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。

14.堆和棧的區別？
答案：管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。
申請大小：
棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在 WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。因此，能從棧得到的空間較小。
堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。
碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出
分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。
分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。

15.什麼是鍵-值,鍵路徑是什麼？
答案：模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。
鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的
性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型
實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相
關對象的特定屬性。

16.目標-動做機制
答案：目標是動做消息的接收者。一個控件，或者更爲常見的是它的單元，以插座變量（參見」插座變量」部分）
的形式保有其動做消息的目標。
動做是控件發送給目標的消息，或者從目標的角度看，它是目標爲了響應動做而實現的方法。
程序須要某些機制來進行事件和指令的翻譯。這個機制就是目標-動做機制。

17.objc的內存管理
答案：若是您經過分配和初始化（好比[[MyClass alloc] init]）的方式來建立對象，您就擁
有這個對象，須要負責該對象的釋放。這個規則在使用NSObject的便利方法new 時也一樣適用。
若是您拷貝一個對象，您也擁有拷貝獲得的對象，須要負責該對象的釋放。
若是您保持一個對象，您就部分擁有這個對象，須要在再也不使用時釋放該對象。
反過來，
若是您從其它對象那裏接收到一個對象，則您不擁有該對象，也不該該釋放它（這個規則有少數的例外，在參考文檔中有顯式的說明）。

18.自動釋放池是什麼,如何工做？
答案：當您向一個對象發送一個autorelease消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。
1）ojc-c 是經過一種」referring counting」(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬.
2）NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的.
3）autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.

19.類工廠方法是什麼
答案：類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中，返回被建立的對象，並
進行自動釋放處理。這些方法的形式是+ (type)className…（其中 className不包括任何前綴）。
工廠方法可能不只僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠爲初始化過程提供對
象的分配信息。
類工廠方法的另外一個目的是使類（好比NSWorkspace）提供單件實例。雖然init…方法能夠確認一
個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。
工廠方法則能夠避免爲可能沒有用的對象盲目分配內存。

20.單件實例是什麼
答案：Foundation 和 Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager 和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配和初始化。單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比
NSWorkspace），就應該產生一個單件實例，而不是多個實例；若是未來某一天可能有多個實例，您可
以使用單件實例機制，而不是工廠方法或函數。

21.動態綁定在運行時肯定要調用的方法
答案：動態綁定將調用方法的肯定也推遲到運行時。在編譯時，方法的調用並不和代碼綁定在一塊兒，只有在消實發送出來以後，才肯定被調用的代碼。經過動態類型和動態綁定技術，您的代碼每次執行均可以獲得不一樣的結果。運行時因子負責肯定消息的接收者和被調用的方法。運行時的消息分發機制爲動態綁定提供支持。當您向一個動態類型肯定了的對象發送消息時，運行環境系統會經過接收者的isa指針定位對象的類，並以此爲起點肯定被調用的方法，方法和消息是動態綁定的。並且，您不必在Objective-C 代碼中作任何工做，就能夠自動獲取動態綁定的好處。您在每次發送消息時，特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而透明地發生。

22.obj-c的優缺點
答案：objc優勢：
1) Cateogies
2) Posing
3) 動態識別
4) 指標計算
5）彈性訊息傳遞
6) 不是一個過分複雜的 C 衍生語言
7) Objective-C 與 C++ 可混合編程
缺點:
1) 不支援命名空間
2) 不支持運算符重載
3）不支持多重繼承
4）使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。

23.sprintf,strcpy,memcpy使用上有什麼要注意的地方
答案：strcpy是一個字符串拷貝的函數，它的函數原型爲strcpy(char *dst, c*****t char *src);
將 src開始的一段字符串拷貝到dst開始的內存中去，結束的標誌符號爲’\0’，因爲拷貝的長度不是由咱們本身控制的，因此這個字符串拷貝很容易出錯。具備字符串拷貝功能的函數有memcpy，這是一個內存拷貝函數，它的函數原型爲memcpy(char *dst, c*****t char* src, unsigned int len);
將長度爲len的一段內存，從src拷貝到dst中去，這個函數的長度可控。可是會有內存疊加的問題。
sprintf是格式化函數。將一段數據經過特定的格式，格式化到一個字符串緩衝區中去。sprintf格式化的函數的長度不可控，有可能格式化後的字符串會超出緩衝區的大小，形成溢出。

24.readwrite，readonly，assign，retain，copy，nonatomic屬性的做用
答案：@property是一個屬性訪問聲明，擴號內支持如下幾個屬性：
1，getter=getterName，setter=setterName，設置setter與getter的方法名
2，readwrite,readonly，設置可供訪問級別
2，assign，setter方法直接賦值，不進行任何retain操做，爲了解決原類型與環循引用問題
3，retain，setter方法對參數進行release舊值再retain新值，全部實現都是這個順序(CC上有相關資料)
4，copy，setter方法進行Copy操做，與retain處理流程同樣，先舊值release，再Copy出新的對象，retainCount爲1。這是爲了減小對上下文的依賴而引入的機制。
copy是在你不但願a和b共享一塊內存時會使用到。a和b各自有本身的內存。
5，nonatomic，非原子性訪問，不加同步，多線程併發訪問會提升性能。注意，若是不加此屬性，則默認是兩個訪問方法都爲原子型事務訪問。鎖被加到所屬對象實例級(我是這麼理解的…)。
atomic和nonatomic用來決定編譯器生成的getter和setter是否爲原子操做。在多線程環境下，原子操做是必要的，不然有可能引發錯誤的結果。加了atomic，setter函數會變成下面這樣：

26何時用delegate，何時用Notification？
答案：delegate針對one-to-one關係，而且reciever能夠返回值給sender，notification 能夠針對one-to-one/many/none,reciever沒法返回值給sender.因此，delegate用於sender但願接受到 reciever的某個功能反饋值，notification用於通知多個object某個事件。

27什麼是KVC和KVO？
答：KVC(Key-Value-Coding)內部的實現：一個對象在調用setValue的時候，（1）首先根據方法名找到運行方法的時候所須要的環境參數。（2）他會從本身isa指針結合環境參數，找到具體的方法實現的接口。（3）再直接查找得來的具體的方法實現。KVO（Key-Value- Observing）：當觀察者爲一個對象的屬性進行了註冊，被觀察對象的isa指針被修改的時候，isa指針就會指向一箇中間類，而不是真實的類。因此 isa指針其實不須要指向實例對象真實的類。因此咱們的程序最好不要依賴於isa指針。在調用類的方法的時候，最好要明確對象實例的類名

28 ViewController 的 loadView, viewDidLoad, viewDidUnload 分別是在何時調用的？
答案：在自定義ViewController的時候這幾個函數裏面應該作什麼工做？答：viewDidLoad在view 從nib文件初始化時調用，loadView在controller的view爲nil時調用。此方法在編程實現view時調用,view 控制器默認會註冊memory warning notification,當view controller的任何view 沒有用的時候，viewDidUnload會被調用，在這裏實現將retain的view release,若是是retain的IBOutlet view 屬性則不要在這裏release,IBOutlet會負責release 。

29.」NSMutableString *」這個數據類型則是表明」NSMutableString」對象自己，這二者是有區別的。而NSString只是對象的指針而已。
答案：面向過程就是分析出解決問題所須要的步驟，而後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就能夠了。
面向對象是把構成問題事務分解成各個對象，創建對象的目的不是爲了完成一個步驟，而是爲了描敘某個事物在整個解決問題的步驟中的行爲。；

30.類別的做用
答案：類別主要有3個做用：
(1)將類的實現分散到多個不一樣文件或多個不一樣框架中。
(2)建立對私有方法的前向引用。
(3)向對象添加非正式協議。
類別的侷限性
有兩方面侷限性：
(1)沒法向類中添加新的實例變量，類別沒有位置容納實例變量。
(2)名稱衝突，即當類別中的方法與原始類方法名稱衝突時，類別具備更高的優先級。類別方法將徹底取代初始方法從而沒法再使用初始方法。
沒法添加實例變量的侷限能夠使用字典對象解決

隨着iOS平臺開發的職位的增長，筆試、面試也愈來愈有「套路」，這裏我總結了一些面試題，多數是Objective-C的基礎知識，適合於面試新人，答案是我本身答的，不許確的地方，歡迎指出。

二

1. Object－c的類能夠多重繼承麼？能夠實現多個接口麼？Category是什麼？重寫一個類的方式用繼承好仍是分類好？爲何？

答案：Object-c的類不能夠多重繼承；能夠實現多個接口，經過實現多個接口能夠完成C++的多重繼承；Category是類別，通常狀況用分類好，用Category去重寫類的方法，僅對本Category有效，不會影響到其餘類與原有類的關係。

2.#import 跟#include 又什麼區別，@class呢, ＃import<> 跟 #import」」又什麼區別？

答案：#import是Objective-C導入頭文件的關鍵字，#include是C/C++導入頭文件的關鍵字,使用#import頭文件會自動只導入一次，不會重複導入，至關於#include和#pragma once；@class告訴編譯器某個類的聲明，當執行時，纔去查看類的實現文件，能夠解決頭文件的相互包含；#import<>用來包含系統的頭文件，#import」」用來包含用戶頭文件。

3. 屬性readwrite，readonly，assign，retain，copy，nonatomic 各是什麼做用，在那種狀況下用？

答案：readwrite 是可讀可寫特性；須要生成getter方法和setter方法時

readonly 是隻讀特性只會生成getter方法不會生成setter方法 ;不但願屬性在類外改變

assign 是賦值特性，setter方法將傳入參數賦值給實例變量；僅設置變量時；

retain 表示持有特性，setter方法將傳入參數先保留，再賦值，傳入參數的retaincount會+1;

copy 表示拷貝特性，setter方法將傳入對象複製一份；須要徹底一份新的變量時。

nonatomic 非原子操做，決定編譯器生成的setter getter是不是原子操做，atomic表示多線程安全，通常使用nonatomic

4.寫一個setter方法用於完成@property （nonatomic,retain）NSString *name,寫一個setter方法用於完成@property（nonatomic，copy）NSString *name

答案：[cpp] view plain copy print ?

- (void) setName:(NSString*) str
{
[str retain];
[name release];
name = str;
}
- (void)setName:(NSString *)str
{
id t = [str copy];
[name release];
name = t;
}

5.對於語句NSString*obj = [[NSData alloc] init]; obj在編譯時和運行時分別時什麼類型的對象？

答案：編譯時是NSString的類型；運行時是NSData類型的對象

6.常見的object-c的數據類型有那些，和C的基本數據類型有什麼區別？如：NSInteger和int

答案：object-c的數據類型有 NSString，NSNumber，NSArray，NSMutableArray，NSData等等，這些都是class，建立後即是對象，而C語言的基本數據類型int，只是必定字節的內存空間，用於存放數值；NSInteger是基本數據類型，並非NSNumber的子類，固然也不是 NSObject的子類。NSInteger是基本數據類型Int或者Long的別名（NSInteger的定義typedef long NSInteger），它的區別在於，NSInteger會根據系統是32位仍是64位來決定是自己是int仍是Long。

7.id 聲明的對象有什麼特性？

答案：Id 聲明的對象具備運行時的特性，便可以指向任意類型的objcetive-c的對象；

8.Objective-C如何對內存管理的,說說你的見解和解決方法?

Objective-C的內存管理主要有三種方式ARC（自動內存計數）、手動內存計數、內存池。

9.內存管理的幾條原則時什麼？按照默認法則.那些關鍵字生成的對象

答案：須要手動釋放？在和property結合的時候怎樣有效的避免內存泄露？

誰申請，誰釋放

遵循Cocoa Touch的使用原則；

內存管理主要要避免「過早釋放」和「內存泄漏」，對於「過早釋放」須要注意@property設置特性時，必定要用對特性關鍵字，對於「內存泄漏」，必定要申請了要負責釋放，要細心。

關鍵字alloc 或new 生成的對象須要手動釋放；

設置正確的property屬性，對於retain須要在合適的地方釋放.

10.如何對iOS設備進行性能測試?

Profile-> Instruments ->Time Profiler

11.看下面的程序,第一個NSLog會輸出什麼？這時str的retainCount是多少？第二個和第三個呢？爲何？

答案：[cpp] view plain copy print ?

=======================================================
NSMutableArray* ary = [[NSMutableArray array] retain];
NSString *str = [NSString stringWithFormat:@"test"];
[strretain];
[aryaddObject:str];
NSLog(@「%@%d」,str,[str retainCount]);
[strretain];
[strrelease];
[strrelease];
NSLog(@「%@%d」,str,[str retainCount]);
[aryremoveAllObjects];
NSLog(@「%@%d」,str,[str retainCount]);
=======================================================

str的retainCount建立+1，retain+1，加入數組自動+1

retain+1，release-1，release-1

數組刪除全部對象，全部數組內的對象自動-1

12. Object C中建立線程的方法是什麼？若是在主線程中執行代碼，方法是什麼？若是想延時執行代碼、方法又是什麼？

答案：線程建立有三種方法：使用NSThread建立、使用GCD的dispatch、使用子類化的 NSOperation,而後將其加入NSOperationQueue;在主線程執行代碼，方法是 performSelectorOnMainThread，若是想延時執行代碼能夠用 performSelector:onThread:withObject:waitUntilDone:

13.描述一下iOS SDK中如何實現MVC的開發模式

答案：MVC是模型、試圖、控制開發模式，對於iOS SDK，全部的View都是視圖層的，它應該獨立於模型層，由視圖控制層來控制。全部的用戶數據都是模型層，它應該獨立於視圖。全部的ViewController都是控制層，由它負責控制視圖，訪問模型數據。

14.關鍵字volatile有什麼含意?並給出三個不一樣的例子：
答案：一個定義爲volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到
這個變量時必須每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子：
• 並行設備的硬件寄存器（如：狀態寄存器）
• 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)
• 多線程應用中被幾個任務共享的變量

• 一個參數既能夠是const還能夠是volatile嗎？解釋爲何。
• 一個指針能夠是volatile 嗎？解釋爲何。

下面是答案：
• 是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。
• 是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。

15.@synthesize 是系統自動生成getter和setter屬性聲明
答案：@dynamic 是開發者自已提供相應的屬性聲明
@dynamic 意思是由開發人員提供相應的代碼：對於只讀屬性須要提供 setter，對於讀寫屬性須要提供 setter 和getter。@synthesize 意思是，除非開發人員已經作了，不然由編譯器生成相應的代碼，以知足屬性聲明。
查閱了一些資料肯定@dynamic的意思是告訴編譯器,屬性的獲取與賦值方法由用戶本身實現, 不自動生成。

16.id、nil表明什麼？
答案：id和void *並不是徹底同樣。在上面的代碼中，id是指向struct objc_object的一個指針，這個意思基本上是說，id是一個指向任何一個繼承了Object（或者NSObject）類的對象。須要注意的是id 是一個指針，因此你在使用id的時候不須要加星號。好比id foo=nil定義了一個nil指針，這個指針指向NSObject的一個任意子類。而id *foo=nil則定義了一個指針，這個指針指向另外一個指針，被指向的這個指針指向NSObject的一個子類。
nil和C語言的NULL相同，在objc/objc.h中定義。nil表示一個Objctive-C對象，這個對象的指針指向空（沒有東西就是空）。
首字母大寫的Nil和nil有一點不同，Nil定義一個指向空的類（是Class，而不是對象）。
SEL是「selector」的一個類型，表示一個方法的名字
Method（咱們常說的方法）表示一種類型，這種類型與selector和實現(implementation)相關
IMP定義爲 id (*IMP) (id, SEL, …)。這樣說來， IMP是一個指向函數的指針，這個被指向的函數包括id(「self」指針)，調用的SEL（方法名），再加上一些其餘參數.說白了IMP就是實現方法。

17.層和UIView的區別是什麼？
答：二者最大的區別是,圖層不會直接渲染到屏幕上，UIView是iOS系統中界面元素的基礎，全部的界面元素都是繼承自它。它自己徹底是由 CoreAnimation來實現的。它真正的繪圖部分，是由一個CALayer類來管理。UIView自己更像是一個CALayer的管理器。一個 UIView上能夠有n個CALayer，每一個layer顯示一種東西，加強UIView的展示能力。

18.GCD爲Grand Central Dispatch的縮寫。
Grand Central Dispatch (GCD)是Apple開發的一個多核編程的較新的解決方法。在Mac OS X 10.6雪豹中首次推出，並在最近引入到了iOS4.0。
GCD是一個替代諸如NSThread等技術的很高效和強大的技術。GCD徹底能夠處理諸如數據鎖定和資源泄漏等複雜的異步編程問題。
GCD能夠完成不少事情，可是這裏僅關注在iOS應用中實現多線程所需的一些基礎知識。
在開始以前，須要理解是要提供給GCD隊列的是代碼塊，用於在系統或者用戶建立的的隊列上調度運行。
聲明一個隊列
以下會返回一個用戶建立的隊列：
dispatch_queue_t myQueue = dispatch_queue_create(「com.iphonedevblog.post」, NULL);其中，第一個參數是標識隊列的，第二個參數是用來定義隊列的參數（目前不支持，所以傳入NULL）。
執行一個隊列
以下會異步執行傳入的代碼：
dispatch_async(myQueue, ^{ [self doSomething]; });其中，首先傳入以前建立的隊列，而後提供由隊列運行的代碼塊。
聲明並執行一個隊列
若是不須要保留要運行的隊列的引用，能夠經過以下代碼實現以前的功能：　　dispatch_async(dispatch_queue_create (「com.iphonedevblog.post」, NULL), ^{ [self doSomething]; });若是須要暫停一個隊列，能夠調用以下代碼。暫停一個隊列會阻止和該隊列相關的全部代碼運行。　　 dispatch_suspend(myQueue);暫停一個隊列
若是暫停一個隊列不要忘記恢復。暫停和恢復的操做和內存管理中的retain和release相似。調用dispatch_suspend會增長暫停計數，而dispatch_resume則會減小。隊列只有在暫停計數變成零的狀況下才開始運行。dispatch_resume(myQueue);恢復一個隊列　　從隊列中在主線程運行代碼有些操做沒法在異步隊列運行，所以必須在主線程（每一個應用都有一個）上運行。UI繪圖以及任何對 NSNotificationCenter的調用必須在主線程長進行。在另外一個隊列中訪問主線程並運行代碼的示例以下：　　 dispatch_sync(dispatch_get_main_queue(), ^{ [self dismissLoginWindow]; });注意，dispatch_suspend （以及dispatch_resume）在主線程上不起做用。
使用GCD，可讓你的程序不會失去響應. 多線程不容易使用，用了GCD，會讓它變得簡單。你無需專門進行線程管理, 很棒！
dispatch_queue_t t1=dispatch_queue_create(「1″, NULL);
dispatch_queue_t t2=dispatch_queue_create(「2″, NULL);
dispatch_async(t1, ^{
[self print1];
});
dispatch_async(t2, ^{
[self print2];
});

19.Provider是指某個iPhone軟件的Push服務器，這篇文章我將使用.net做爲Provider。
答案：APNS 是Apple Push Notification Service（Apple Push服務器）的縮寫，是蘋果的服務器。
上圖能夠分爲三個階段。
第一階段：.net應用程序把要發送的消息、目的iPhone的標識打包，發給APNS。
第二階段：APNS在自身的已註冊Push服務的iPhone列表中，查找有相應標識的iPhone，並把消息發到iPhone。
第三階段：iPhone把發來的消息傳遞給相應的應用程序，而且按照設定彈出Push通知。
http://blog.csdn.net/zhuqilin0/article/details/6527113 //消息推送機制
看內存泄露時候：在搜索中搜索run 找到Run Static Snalyzer .

20.可擴展標記語言extensible markup language;XML
答案：1)用於標記電子文件使其具備結構性的標記語言，
2)能夠用來標記數據、定義數據類型，是一種容許用戶對本身的標記語言進行定義的源語言。
3)數據庫提供了更強有力的數據存儲和分析能力，例如：數據索引、排序、查找、相關一致性等，XML僅僅是存儲數據。
4)XML與HTML的設計區別是：XML的核心是數據，其重點是數據的內容。而HTML 被設計用來顯示數據，其重點是數據的顯示。
5)XML和HTML語法區別：HTML的標記不是全部的都須要成對出現，XML則要求全部的標記必須成對出現；HTML標記不區分大小寫，XML則大小敏感,即區分大小寫。
結合
XML的簡單使其易於在任何應用程序中讀寫數據，這使XML很快成爲數據交換的惟一公共語言，雖然不一樣的應用軟件也支持其它的數據交換格式，但不久以後他們都將支持XML，那就意味着程序能夠更容易的與Windows,Mac OS,Linux以及其餘平臺下產生的信息結合，而後能夠很容易加載XML數據到程序中並分析他，並以XML格式輸出結果。
XML去掉了以前令許多開發人員頭疼的SGML（標準通用標記語言）的隨意語法。在XML中，採用了以下的語法：
1 任何的起始標籤都必須有一個結束標籤。
2 能夠採用另外一種簡化語法，能夠在一個標籤中同時表示起始和結束標籤。這種語法是在大於符號以前緊跟一個斜線（/），例如<tag/ >。XML解析器會將其翻譯成<tag></tag>。
3 標籤必須按合適的順序進行嵌套，因此結束標籤必須按鏡像順序匹配起始標籤，例如this is asamplestring。這比如是將起始和結束標籤看做是數學中的左右括號：在沒有關閉全部的內部括號以前，是不能關閉外面的括號的。
4 全部的特性都必須有值。
5 全部的特性都必須在值的周圍加上雙引號。

21.代碼分析
union u
{
double a;
int b;
};

union u2
{
char a[13];
int b;
};

union u3
{
char a[13];
char b;
};

cout<<sizeof(u)<<endl; // 8
cout<<sizeof(u2)<<endl; // 16
cout<<sizeof(u3)<<endl; // 13
都知道union的大小取決於它全部的成員中，佔用空間最大的一個成員的大小。因此對於u來講，大小就是最大的double類型成員a了，因此 sizeof(u)=sizeof(double)=8。可是對於u2和u3，最大的空間都是char[13]類型的數組，爲何u3的大小是13，而 u2是16呢？關鍵在於u2中的成員int b。因爲int類型成員的存在，使u2的對齊方式變成4，也就是說，u2的大小必須在4的對界上，因此佔用的空間變成了16（最接近13的對界）。 struct s1
{
char a;
double b;
int c;
char d;
};

struct s2
{
char a;
char b;
int c;
double d;
};

cout<<sizeof(s1)<<endl; // 24
cout<<sizeof(s2)<<endl; // 16

一樣是兩個char類型，一個int類型，一個double類型，可是由於對界問題，致使他們的大小不一樣。計算結構體大小能夠採用元素擺放法，我舉例子說明一下：首先，CPU判斷結構體的對界，根據上一節的結論，s1和s2的對界都取最大的元素類型，也就是double類型的對界8。而後開始擺放每一個元素。

對於s1，首先把a放到8的對界，假定是0，此時下一個空閒的地址是1，可是下一個元素d是double類型，要放到8的對界上，離1最接近的地址是8了，因此d被放在了8，此時下一個空閒地址變成了16，下一個元素c的對界是4，16能夠知足，因此c放在了16，此時下一個空閒地址變成了20，下一個元素d須要對界1，也正好落在對界上，因此d放在了20，結構體在地址21處結束。因爲s1的大小須要是8的倍數，因此21- 23的空間被保留，s1的大小變成了24。

對於s2，首先把a放到8的對界，假定是0，此時下一個空閒地址是1，下一個元素的對界也是1，因此b擺放在1，下一個空閒地址變成了2；下一個元素c的對界是4，因此取離2最近的地址4擺放c，下一個空閒地址變成了8，下一個元素d的對界是 8，因此d擺放在8，全部元素擺放完畢，結構體在15處結束，佔用總空間爲16，正好是8的倍數。
22.ASIDownloadCache 設置下載緩存
答案：它對Get請求的響應數據進行緩存（被緩存的數據必需是成功的200請求）：
[ASIHTTPRequest setDefaultCache:[ASIDownloadCache sharedCache]];
當設置緩存策略後，全部的請求都被自動的緩存起來。
另外，若是僅僅但願某次請求使用緩存操做，也能夠這樣使用：
ASIHTTPRequest *request = [ASIHTTPRequest requestWithURL:url];
[request setDownloadCache:[ASIDownloadCache sharedCache]];
緩存存儲方式
你能夠設置緩存的數據須要保存多長時間，ASIHTTPRequest提供了兩種策略：
a，ASICacheForSessionDurationCacheStoragePolicy，默認策略，基於session的緩存數據存儲。當下次運行或[ASIHTTPRequest clearSession]時，緩存將失效。
b，ASICachePermanentlyCacheStoragePolicy，把緩存數據永久保存在本地，
如：
ASIHTTPRequest *request = [ ASIHTTPRequest requestWithURL:url ];
[ request setCacheStoragePolicy:ASICachePermanentlyCacheStoragePolicy ];

23.HTTP協議詳解
答案：HTTP是一個屬於應用層的面向對象的協議，因爲其簡捷、快速的方式，適用於分佈式超媒體信息系統。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的規範化工做正在進行之中。
http（超文本傳輸協議）是一個基於請求與響應模式的、無狀態的、應用層的協議，常基於TCP的鏈接方式，HTTP1.1版本中給出一種持續鏈接的機制，絕大多數的Web開發，都是構建在HTTP協議之上的Web應用。
HTTP協議的主要特色可歸納以下：
1.支持客戶/服務器模式。
2.簡單快速：客戶向服務器請求服務時，只需傳送請求方法和路徑。請求方法經常使用的有GET、HEAD、POST。每種方法規定了客戶與服務器聯繫的類型不一樣。因爲HTTP協議簡單，使得HTTP服務器的程序規模小，於是通訊速度很快。
3.靈活：HTTP容許傳輸任意類型的數據對象。正在傳輸的類型由Content-Type加以標記。
4.無鏈接：無鏈接的含義是限制每次鏈接只處理一個請求。服務器處理完客戶的請求，並收到客戶的應答後，即斷開鏈接。採用這種方式能夠節省傳輸時間。
5.無狀態：HTTP協議是無狀態協議。無狀態是指協議對於事務處理沒有記憶能力。缺乏狀態意味着若是後續處理須要前面的信息，則它必須重傳，這樣可能致使每次鏈接傳送的數據量增大。另外一方面，在服務器不須要先前信息時它的應答就較快。

24.URL
答案：HTTP URL (URL是一種特殊類型的URI是他的子類，包含了用於查找某個資源的足夠的信息)的格式以下：
[url=http://host[%22%22port][abs_path/]http://host[":"port][abs_path[/url]]
http表示要經過HTTP協議來定位網絡資源；host表示合法的Internet主機域名或者IP地址；port指定一個端口號，爲空則使用缺省端口 80；abs_path指定請求資源的URI；若是URL中沒有給出abs_path，那麼當它做爲請求URI時，必須以「/」的形式給出，一般這個工做瀏覽器自動幫咱們完成。

25.TCP/UDP區別聯繫
答案：TCP—傳輸控制協議,提供的是面向鏈接、可靠的字節流服務。當客戶和服務器彼此交換數據前，必須先在雙方之間創建一個TCP鏈接，以後才能傳輸數據。TCP提供超時重發，丟棄重複數據，檢驗數據，流量控制等功能，保證數據能從一端傳到另外一端。
UDP—用戶數據報協議，是一個簡單的面向數據報的運輸層協議。UDP不提供可靠性，它只是把應用程序傳給IP層的數據報發送出去，可是並不能保證它們能到達目的地。因爲UDP在傳輸數據報前不用在客戶和服務器之間創建一個鏈接，且沒有超時重發等機制，故而傳輸速度很快
TCP（Transmission Control Protocol，傳輸控制協議）是基於鏈接的協議，也就是說，在正式收發數據前，必須和對方創建可靠的鏈接。一個TCP鏈接必需要通過三次「對話」才能創建起來，咱們來看看這三次對話的簡單過程：1.主機A向主機B發出鏈接請求數據包；2.主機B向主機A發送贊成鏈接和要求同步（同步就是兩臺主機一個在發送，一個在接收，協調工做）的數據包；3.主機A再發出一個數據包確認主機B的要求同步：「我如今就發，你接着吧！」，這是第三次對話。三次「對話」的目的是使數據包的發送和接收同步，通過三次「對話」以後，主機A才向主機B正式發送數據。
UDP（User Data Protocol，用戶數據報協議）是與TCP相對應的協議。它是面向非鏈接的協議，它不與對方創建鏈接，而是直接就把數據包發送過去！ UDP適用於一次只傳送少許數據、對可靠性要求不高的應用環境。
tcp協議和udp協議的差異
是否鏈接面向鏈接面向非鏈接
傳輸可靠性可靠不可靠
應用場合傳輸大量數據少許數據
速度慢快

26.socket鏈接和http鏈接的區別
答案：簡單說，你瀏覽的網頁（網址以http://開頭)都是http協議傳輸到你的瀏覽器的, 而http是基於socket之上的。socket是一套完成tcp，udp協議的接口。
HTTP協議：簡單對象訪問協議，對應於應用層，HTTP協議是基於TCP鏈接的
tcp協議：對應於傳輸層
ip協議：對應於網絡層
TCP/IP是傳輸層協議，主要解決數據如何在網絡中傳輸；而HTTP是應用層協議，主要解決如何包裝數據。
Socket是對TCP/IP協議的封裝，Socket自己並非協議，而是一個調用接口（API），經過Socket，咱們才能使用TCP/IP協議。
http鏈接：http鏈接就是所謂的短鏈接，即客戶端向服務器端發送一次請求，服務器端響應後鏈接即會斷掉；
socket鏈接：socket鏈接就是所謂的長鏈接，理論上客戶端和服務器端一旦創建起鏈接將不會主動斷掉；可是因爲各類環境因素可能會是鏈接斷開，好比說：服務器端或客戶端主機down了，網絡故障，或者二者之間長時間沒有數據傳輸，網絡防火牆可能會斷開該鏈接以釋放網絡資源。因此當一個socket鏈接中沒有數據的傳輸，那麼爲了維持鏈接須要發送心跳消息~~具體心跳消息格式是開發者本身定義的
咱們已經知道網絡中的進程是經過socket來通訊的，那什麼是socket呢？socket起源於Unix，而Unix/Linux基本哲學之一就是「一切皆文件」，均可以用「打開open –> 讀寫write/read –> 關閉close」模式來操做。個人理解就是Socket就是該模式的一個實現，socket便是一種特殊的文件，一些socket函數就是對其進行的操做（讀/寫IO、打開、關閉），這些函數咱們在後面進行介紹。咱們在傳輸數據時，能夠只使用（傳輸層）TCP/IP協議，可是那樣的話，若是沒有應用層，便沒法識別數據內容，若是想要使傳輸的數據有意義，則必須使用到應用層協議，應用層協議有不少，好比HTTP、FTP、TELNET等，也能夠本身定義應用層協議。WEB使用HTTP協議做應用層協議，以封裝HTTP文本信息，而後使用TCP/IP作傳輸層協議將它發到網絡上。
1)Socket是一個針對TCP和UDP編程的接口，你能夠藉助它創建TCP鏈接等等。而TCP和UDP協議屬於傳輸層。
而http是個應用層的協議，它實際上也創建在TCP協議之上。
(HTTP是轎車，提供了封裝或者顯示數據的具體形式；Socket是發動機，提供了網絡通訊的能力。)
2）Socket是對TCP/IP協議的封裝，Socket自己並非協議，而是一個調用接口（API），經過Socket，咱們才能使用TCP/IP協議。Socket的出現只是使得程序員更方便地使用TCP/IP協議棧而已，是對TCP/IP協議的抽象，從而造成了咱們知道的一些最基本的函數接口。

27.什麼是TCP鏈接的三次握手
答案：第一次握手：客戶端發送syn包(syn=j)到服務器，並進入SYN_SEND狀態，等待服務器確認；
第二次握手：服務器收到syn包，必須確認客戶的SYN（ack=j+1），同時本身也發送一個SYN包（syn=k），即SYN+ACK包，此時服務器進入SYN_RECV狀態；
第三次握手：客戶端收到服務器的SYN＋ACK包，向服務器發送確認包ACK(ack=k+1)，此包發送完畢，客戶端和服務器進入ESTABLISHED狀態，完成三次握手。
握手過程當中傳送的包裏不包含數據，三次握手完畢後，客戶端與服務器才正式開始傳送數據。理想狀態下，TCP鏈接一旦創建，在通訊雙方中的任何一方主動關閉鏈接以前，TCP 鏈接都將被一直保持下去。斷開鏈接時服務器和客戶端都可以主動發起斷開TCP鏈接的請求，斷開過程須要通過「四次握手」（過程就不細寫了，就是服務器和客戶端交互，最終肯定斷開）

28.利用Socket創建網絡鏈接的步驟
答案：創建Socket鏈接至少須要一對套接字，其中一個運行於客戶端，稱爲ClientSocket ，另外一個運行於服務器端，稱爲ServerSocket 。
套接字之間的鏈接過程分爲三個步驟：服務器監聽，客戶端請求，鏈接確認。
1。服務器監聽：服務器端套接字並不定位具體的客戶端套接字，而是處於等待鏈接的狀態，實時監控網絡狀態，等待客戶端的鏈接請求。
2。客戶端請求：指客戶端的套接字提出鏈接請求，要鏈接的目標是服務器端的套接字。爲此，客戶端的套接字必須首先描述它要鏈接的服務器的套接字，指出服務器端套接字的地址和端口號，而後就向服務器端套接字提出鏈接請求。
3。鏈接確認：當服務器端套接字監聽到或者說接收到客戶端套接字的鏈接請求時，就響應客戶端套接字的請求，創建一個新的線程，把服務器端套接字的描述發給客戶端，一旦客戶端確認了此描述，雙方就正式創建鏈接。而服務器端套接字繼續處於監聽狀態，繼續接收其餘客戶端套接字的鏈接請求。

29.進程與線程
答案：進程（process）是一塊包含了某些資源的內存區域。操做系統利用進程把它的工做劃分爲一些功能單元。
進程中所包含的一個或多個執行單元稱爲線程（thread）。進程還擁有一個私有的虛擬地址空間，該空間僅能被它所包含的線程訪問。
一般在一個進程中能夠包含若干個線程，它們能夠利用進程所擁有的資源。
在引入線程的操做系統中，一般都是把進程做爲分配資源的基本單位，而把線程做爲獨立運行和獨立調度的基本單位。
因爲線程比進程更小，基本上不擁有系統資源，故對它的調度所付出的開銷就會小得多，能更高效的提升系統內多個程序間併發執行的程度。
簡而言之,一個程序至少有一個進程,一個進程至少有一個線程.一個程序就是一個進程，而一個程序中的多個任務則被稱爲線程。
線程只能歸屬於一個進程而且它只能訪問該進程所擁有的資源。當操做系統建立一個進程後，該進程會自動申請一個名爲主線程或首要線程的線程。應用程序（application）是由一個或多個相互協做的進程組成的。
另外，進程在執行過程當中擁有獨立的內存單元，而多個線程共享內存，從而極大地提升了程序的運行效率。
線程在執行過程當中與進程仍是有區別的。每一個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。可是線程不可以獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。
從邏輯角度來看，多線程的意義在於一個應用程序中，有多個執行部分能夠同時執行。但操做系統並無將多個線程看作多個獨立的應用，來實現進程的調度和管理以及資源分配。這就是進程和線程的重要區別。
進程是具備必定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位.
線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程本身基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),可是它可與同屬一個進程的其餘的線程共享進程所擁有的所有資源.
一個線程能夠建立和撤銷另外一個線程;同一個進程中的多個線程之間能夠併發執行.

30.多線程
答案：多線程編程是防止主線程堵塞，增長運行效率等等的最佳方法。而原始的多線程方法存在不少的毛病，包括線程鎖死等。在Cocoa中，Apple提供了NSOperation這個類，提供了一個優秀的多線程編程方法。
本次介紹NSOperation的子集，簡易方法的NSInvocationOperation：
一個NSOperationQueue 操做隊列，就至關於一個線程管理器，而非一個線程。由於你能夠設置這個線程管理器內能夠並行運行的的線程數量等等

三

1.Difference between shallow copy and deep copy?
淺複製和深複製的區別？
答案：淺層複製：只複製指向對象的指針，而不復制引用對象自己。
深層複製：複製引用對象自己。
意思就是說我有個A對象，複製一份後獲得A_copy對象後，對於淺複製來講，A和A_copy指向的是同一個內存資源，複製的只不過是是一個指針，對象自己資源
仍是隻有一份，那若是咱們對A_copy執行了修改操做,那麼發現A引用的對象一樣被修改，這其實違背了咱們複製拷貝的一個思想。深複製就好理解了,內存中存在了
兩份獨立對象自己。
用網上一哥們通俗的話將就是：
淺複製比如你和你的影子，你完蛋，你的影子也完蛋
深複製比如你和你的克隆人，你完蛋，你的克隆人還活着。

2.What is advantage of categories? What is difference between implementing a category and inheritance?
類別的做用？繼承和類別在實現中有何區別？
答案：category 能夠在不獲悉，不改變原來代碼的狀況下往裏面添加新的方法，只能添加，不能刪除修改。
而且若是類別和原來類中的方法產生名稱衝突，則類別將覆蓋原來的方法，由於類別具備更高的優先級。
類別主要有3個做用：
(1)將類的實現分散到多個不一樣文件或多個不一樣框架中。
(2)建立對私有方法的前向引用。
(3)向對象添加非正式協議。
繼承能夠增長，修改或者刪除方法，而且能夠增長屬性。

3.Difference between categories and extensions?
類別和類擴展的區別。
答案：category和extensions的不一樣在於後者能夠添加屬性。另外後者添加的方法是必需要實現的。
extensions能夠認爲是一個私有的Category。

4.Difference between protocol in objective c and interfaces in java?
oc中的協議和java中的接口概念有何不一樣？
答案：OC中的協議有2層含義，官方定義爲 formal和informal protocol。前者和Java接口同樣。
informal protocol中的方法屬於設計模式考慮範疇，不是必須實現的，可是若是有實現，就會改變類的屬性。
其實關於正式協議，類別和非正式協議我很早前學習的時候大體看過，也寫在了學習教程裏
「非正式協議概念其實就是類別的另外一種表達方式「這裏有一些你可能但願實現的方法，你能夠使用他們更好的完成工做」。
這個意思是，這些是可選的。好比我門要一個更好的方法，咱們就會申明一個這樣的類別去實現。而後你在後期能夠直接使用這些更好的方法。
這麼看，總以爲類別這玩意兒有點像協議的可選協議。」
如今來看，其實protocal已經開始對二者都統一和規範起來操做，由於資料中說「非正式協議使用interface修飾「，
如今咱們看到協議中兩個修飾詞：「必須實現(@requied)」和「可選實現(@optional)」。

OC中的協議(formal protocol)與java中的接口概念基本一致，OC中非正式協議(informal protocol)就是類別。在java中若是繼承了接口，但不實現其方法，會獲得一個error（沒法編譯）；在OC中的正式協議，若是不實現，會獲得一個warning（可編譯執行），若是想去除waring，還能夠加關鍵字（@optional），讓它可選實現方法。

#pragma mark KVO

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

對於系統是根據keypath去取的到相應的值發生改變，理論上來講是和kvc機制的道理是同樣的。
對於kvc機制如何經過key尋找到value：
「當經過KVC調用對象時，好比：[self valueForKey:@」someKey」]時，程序會自動試圖經過幾種不一樣的方式解析這個調用。首先查找對象是否帶有 someKey 這個方法，若是沒找到，會繼續查找對象是否帶有someKey這個實例變量（iVar），若是尚未找到，程序會繼續試圖調用 -(id) valueForUndefinedKey:這個方法。若是這個方法仍是沒有被實現的話，程序會拋出一個NSUndefinedKeyException 異常錯誤。

(cocoachina.com注：Key-Value Coding查找方法的時候，不只僅會查找someKey這個方法，還會查找getsomeKey這個方法，前面加一個get，或者_someKey以及 _getsomeKey這幾種形式。同時，查找實例變量的時候也會不只僅查找someKey這個變量，也會查找_someKey這個變量是否存在。）

設計valueForUndefinedKey:方法的主要目的是當你使用-(id)valueForKey方法從對象中請求值時，對象可以在錯誤發生前，有最後的機會響應這個請求。這樣作有不少好處，下面的兩個例子說明了這樣作的好處。「
來至cocoa，這個說法應該挺有道理。
由於咱們知道button倒是存在一個highlighted實例變量.所以爲什麼上面咱們只是add一個相關的keypath就好了，
能夠按照kvc查找的邏輯理解，就說的過去了。

6.What is purpose of delegates?
代理的做用？
答案：代理的目的是改變或傳遞控制鏈。容許一個類在某些特定時刻通知到其餘類，而不須要獲取到那些類的指針。能夠減小框架複雜度。
另一點，代理能夠理解爲java中的回調監聽機制的一種相似。

7.What are mutable and immutable types in Objective C?
oc中可修改和不能夠修改類型。
答案：可修改不可修改的集合類。這個我我的簡單理解就是可動態添加修改和不可動態添加修改同樣。
好比NSArray和NSMutableArray。前者在初始化後的內存控件就是固定不可變的，後者能夠添加等，能夠動態申請新的內存空間。

8.When we call objective c is runtime language what does it mean?
咱們說的oc是動態運行時語言是什麼意思？
答案：多態。主要是將數據類型的肯定由編譯時，推遲到了運行時。
這個問題其實淺涉及到兩個概念，運行時和多態。
簡單來講，運行時機制使咱們直到運行時纔去決定一個對象的類別，以及調用該類別對象指定方法。
多態：不一樣對象以本身的方式響應相同的消息的能力叫作多態。意思就是假設生物類（life）都用有一個相同的方法-eat;
那人類屬於生物，豬也屬於生物，都繼承了life後，實現各自的eat，可是調用是咱們只需調用各自的eat方法。
也就是不一樣的對象以本身的方式響應了相同的消息（響應了eat這個選擇器）。
所以也能夠說，運行時機制是多態的基礎？~~~

9.what is difference between NSNotification and protocol?
通知和協議的不一樣之處？
答案：協議有控制鏈(has-a)的關係，通知沒有。
首先我一開始也不太明白，什麼叫控制鏈（專業術語了~）。可是簡單分析下通知和代理的行爲模式，咱們大體能夠有本身的理解
簡單來講，通知的話，它能夠一對多，一條消息能夠發送給多個消息接受者。
代理按咱們的理解，到不是直接說不能一對多，好比咱們知道的明星經濟代理人，不少時候一個經濟人負責好幾個明星的事務。
只是對於不一樣明星間，代理的事物對象都是不同的，一一對應，不可能說明天要處理A明星要一個發佈會，代理人發出處理髮佈會的消息後，別稱B的
發佈會了。可是通知就不同，他只關心發出通知，而不關心多少接收到感興趣要處理。
所以控制鏈（has-a從英語單詞大體能夠看出，單一擁有和可控制的對應關係。

10.What is push notification?
什麼是推送消息？
答案：太簡單，不做答~~~~~~~~~~
這是cocoa上的答案。
其實到不是說太簡單，只是太泛泛的一個概念的東西。就比如說，什麼是人。
推送通知更是一種技術。
簡單點就是客戶端獲取資源的一種手段。
普通狀況下，都是客戶端主動的pull。
推送則是服務器端主動push。測試push的實現能夠查看該博文。

11.Polymorphism？
關於多態性
答案：多態，子類指針能夠賦值給父類。
這個題目其實能夠出到一切面向對象語言中，
所以關於多態，繼承和封裝基本最好都有個自我意識的理解，也並不是必定要把書上資料上寫的能背出來。
最重要的是轉化成自我理解。

12.Singleton?
對於單例的理解
答案：11，12題目其實出的有點泛泛的感受了，可能說是編程語言須要或是必備的基礎。
基本能用熟悉的語言寫出一個單例，以及能夠運用到的場景或是你編程中碰到過運用的此種模式的框架類等。
進一步點，考慮下如何在多線程訪問單例時的安全性。

13.What is responder chain?
說說響應鏈
答案：事件響應鏈。包括點擊事件，畫面刷新事件等。在視圖棧內從上至下，或者從下之上傳播。
能夠說點事件的分發，傳遞以及處理。具體能夠去看下touch事件這塊。由於問的太抽象化了
嚴重懷疑題目出到越後面就越籠統。

能夠從責任鏈模式，來說經過事件響應鏈處理，其擁有的擴展性

14.Difference between frame and bounds?
frame和bounds有什麼不一樣？
答案:frame指的是：該view在父view座標系統中的位置和大小。（參照點是父親的座標系統）
bounds指的是：該view在自己座標系統中的位置和大小。（參照點是自己座標系統）

15.Difference between method and selector?
方法和選擇器有何不一樣？
答案：selector是一個方法的名字，method是一個組合體，包含了名字和實現.
詳情能夠看apple文檔。

16.Is there any garbage collection mechanism in Objective C.?
OC的垃圾回收機制？
答案： OC2.0有Garbage collection，可是iOS平臺不提供。
通常咱們瞭解的objective-c對於內存管理都是手動操做的，可是也有自動釋放池。
可是差了大部分資料，貌似不要和arc機制搞混就行了。
求更多~~

17.NSOperation queue?
答案：存放NSOperation的集合類。
操做和操做隊列，基本能夠當作java中的線程和線程池的概念。用於處理ios多線程開發的問題。
網上部分資料提到一點是，雖然是queue，可是卻並非帶有隊列的概念，放入的操做並不是是按照嚴格的先進現出。
這邊又有個疑點是，對於隊列來講，先進先出的概念是Afunc添加進隊列，Bfunc緊跟着也進入隊列，Afunc先執行這個是必然的，
可是Bfunc是等Afunc徹底操做完之後，B纔開始啓動而且執行，所以隊列的概念理論上有點違背了多線程處理這個概念。
可是轉念一想其實能夠參考銀行的取票和叫號系統。
所以對於A比B先排隊取票可是B率先執行完操做，咱們亦然能夠感性認爲這仍是一個隊列。
可是後來看到一票關於這操做隊列話題的文章，其中有一句提到
「由於兩個操做提交的時間間隔很近，線程池中的線程，誰先啓動是不定的。」
瞬間以爲這個queue名字有點忽悠人了，還不如pool~
綜合一點，咱們知道他能夠比較大的用處在於能夠幫助多線程編程就行了。

樓上區分了線程執行時的次序（Afunc和Bfunc誰先啓動）和線程執行完成（Afunc和Bfunc誰先執行完）時的次序不一樣，而多線程的重要概念是併發（同時執行多個任務），NSOperationQueue是管理併發線程的對象，能夠在其中放入NSOpertation對象（對象化的線程實體），經過設置maxConcurrentOperationCount的大小，控制併發數目，如樓上所說但願「Afunc添加進隊列，執行完後，Bfunc緊跟進入隊列，繼續執行」，那隻需將maxConcurrentOperationCount設爲1，變會依次執行，這時候實際是在單線程依次執行。因此這裏的NSOperationQueue就是對象化抽象的去管理多線程，這樣的好處，使用者經過繼承NSOperation對象，能夠方便的用對象來管理線程，而再也不用關心線程同步、信號量等細節，更多地關注於業務邏輯。

18.What is lazy loading?
答案：懶漢模式，只在用到的時候纔去初始化。
也能夠理解成延時加載。
我以爲最好也最簡單的一個列子就是tableView中圖片的加載顯示了。
一個延時載，避免內存太高，一個異步加載，避免線程堵塞。

19.Can we use two tableview controllers on one viewcontroller?
是否在一個視圖控制器中嵌入兩個tableview控制器？
答案：一個視圖控制只提供了一個View視圖，理論上一個tableViewController也不能放吧，
只能說能夠嵌入一個tableview視圖。固然，題目自己也有歧義，若是不是咱們定性思惟認爲的UIViewController，
而是宏觀的表示視圖控制者，那咱們卻是能夠把其當作一個視圖控制者，它能夠控制多個視圖控制器，好比TabbarController
那樣的感受。

20.Can we use one tableview with two different datasources? How you will achieve this?
一個tableView是否能夠關聯兩個不一樣的數據源？你會怎麼處理？
答案：首先咱們從代碼來看，數據源如何關聯上的，實際上是在數據源關聯的代理方法裏實現的。
所以咱們並不關心如何去關聯他，他怎麼關聯上，方法只是讓我返回根據本身的須要去設置如相關的數據源。
所以，我以爲能夠設置多個數據源啊，可是有個問題是，你這是想幹嗎呢？想讓列表如何顯示，不一樣的數據源分區塊顯示？

四

1.When to use NSMutableArray and when to use NSArray?

何時使用NSMutableArray，何時使用NSArray？

答案：當數組在程序運行時，須要不斷變化的，使用NSMutableArray，當數組在初始化後，便再也不改變的，使用NSArray。須要指出的是，使用NSArray只代表的是該數組在運行時不發生改變，即不能往NSAarry的數組裏新增和刪除元素，但不代表其數組內的元素的內容不能發生改變。NSArray是線程安全的，NSMutableArray不是線程安全的，多線程使用到NSMutableArray須要注意。

2.Give us example of what are delegate methods and what are data source methods of uitableview.

給出委託方法的實例，而且說出UITableVIew的Data Source方法

答案：CocoaTouch框架中用到了大量委託，其中UITableViewDelegate就是委託機制的典型應用，是一個典型的使用委託來實現適配器模式，其中UITableViewDelegate協議是目標，tableview是適配器，實現UITableViewDelegate協議，並將自身設置爲talbeview的delegate的對象，是被適配器，通常狀況下該對象是UITableViewController。

UITableVIew的Data Source方法有- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section;

– (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath;

3.How many autorelease you can create in your application? Is there any limit?

在應用中能夠建立多少autorelease對象，是否有限制？

答案：無

4.If we don’t create any autorelease pool in our application then is there any autorelease pool already provided to us?

若是咱們不建立內存池，是否有內存池提供給咱們？

答案:界面線程維護着本身的內存池，用戶本身建立的數據線程，則須要建立該線程的內存池

5.When you will create an autorelease pool in your application?

何時須要在程序中建立內存池？

答案：用戶本身建立的數據線程，則須要建立該線程的內存池

6.When retain count increase?

何時內存計數會增長？

答案：應聘ios開發工程師常見的面試題(二)

7.What are commonly used NSObject class methods?

類NSObject的那些方法常常被使用？

答案：NSObject是Objetive-C的基類，其由NSObject類及一系列協議構成。

其中類方法alloc、class、 description 對象方法init、dealloc、– performSelector:withObject:afterDelay:等常常被使用

8.What is convenience constructor?

什麼是簡便構造方法？

答案：簡便構造方法通常由CocoaTouch框架提供，如NSNumber 的 + numberWithBool: + numberWithChar: + numberWithDouble: + numberWithFloat: + numberWithInt:

Foundation下大部分類均有簡便構造方法，咱們能夠經過簡便構造方法，得到系統給咱們建立好的對象，而且不須要手動釋放。

9.How to design universal application in Xcode?

如何使用Xcode設計通用應用？

答案：使用MVC模式設計應用，其中Model層完成脫離界面，即在Model層，其是可運行在任何設備上，在controller層，根據iPhone與iPad（獨有 UISplitViewController）的不一樣特色選擇不一樣的viewController對象。在View層，可根據現實要求，來設計，其中以 xib文件設計時，其設置其爲universal。

10.What is keyword atomic in Objective C?

在Objetive-C什麼時原子關鍵字

答案：atomic，nonatomic 詳見應聘ios開發工程師常見的面試題(二)

11.What are UIView animations?

UIView的動畫效果有那些？

答案：有不少，如 UIViewAnimationOptionCurveEaseInOut UIViewAnimationOptionCurveEaseIn UIViewAnimationOptionCurveEaseOut UIViewAnimationOptionTransitionFlipFromLeft UIViewAnimationOptionTransitionFlipFromRight UIViewAnimationOptionTransitionCurlUpUIViewAnimationOptionTransitionCurlDown

12.How can you store data in iPhone applications?

在iPhone應用中如何保存數據？

答案：有如下幾種保存機制：

1.經過web服務，保存在服務器上

2.經過NSCoder固化機制，將對象保存在文件中

3.經過SQlite或CoreData保存在文件數據庫中

13.What is coredata?

什麼是coredata？

答案：coredata框架是apple提供的一套通用自動的解決方案，包括了對象生存週期、對象關係圖、持久化機制。

補充答案：上面是翻譯的，按我我的理解coredata提供一種一機制，讓咱們能夠方便的把內存中對象，及對象間的關係，映射到coredata，而後由它爲咱們持久化數據。相比普通的文件數據庫SQlite，它的功能更強大，不須要咱們先將對象數據format成SQL語句，存入數據庫，再用 select語句讀出，而如今是從內存到coredata的數據管理，咱們只需管理coredata的managed對象。

是蘋果提供一套數據保存

14.What is NSManagedObject model?

什麼是NSManagedObject模型？

答案：NSManagedObject是NSObject的子類，也是coredata的重要組成部分，它是一個通用的類,實現了core data 模型層所需的基本功能，用戶可經過子類化NSManagedObject，創建本身的數據模型。

15.What is NSManagedobjectContext?

什麼是NSManagedobjectContext？

答案：NSManagedobjectContext對象負責應用和數據庫之間的交互。

16.What is predicate?

什麼是謂詞？

答案：謂詞是經過NSPredicate，是經過給定的邏輯條件做爲約束條件，完成對數據的篩選。

predicate = [NSPredicate predicateWithFormat:@"customerID == %d",n];

a = [customers filteredArrayUsingPredicate:predicate];

17.What kind of persistence store we can use with coredata?

coredata有哪幾種持久化存儲機制？

答案：coredatat提供如下幾種存儲機制：XML（iOS系統不支持）,自動存儲,SQLite,內存存儲。

補充說明：這個問題問的是，coredate框架的存儲機制，平時使用coredata時，更多關注的是managed的對象，這裏是coerdata框架的存儲實現細節。BTW: 其餘經常使用的持久化存儲方法：存入到文件、存入到NSUserDefaults（系統plist文件中）。

18 談談對Block 的理解？並寫出一個使用Block執行UIVew動畫？

答案：Block是能夠獲取其餘函數局部變量的匿名函數，其不但方便開發，而且能夠大幅提升應用的執行效率（多核心CPU可直接處理Block指令）

[cpp] view plaincopyprint?

[UIView transitionWithView:self.view
duration:0.2
options:UIViewAnimationOptionTransitionFlipFromLeft
animations:^{ [[blueViewController view] removeFromSuperview]; [[self view] insertSubview:yellowViewController.view atIndex:0]; }
completion:NULL];

19 寫出上面代碼的Block的定義。

答案：

typedef void(^animations) (void);

typedef void(^completion) (BOOL finished);

20 試着使用+ beginAnimations:context:以及上述Block的定義，寫出一個能夠完成

+ (void)transitionWithView:(UIView *)view duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);操做的函數執行部分

答案：網絡部分

21 作過的項目是否涉及網絡訪問功能，使用什麼對象完成網絡功能？

答案：ASIHTTPRequest與NSURLConnection

22 簡單介紹下NSURLConnection類及+ sendSynchronousRequest:returningResponse:error:與– initWithRequest:delegate:兩個方法的區別？

答案: NSURLConnection主要用於網絡訪問，其中+ sendSynchronousRequest:returningResponse:error:是同步訪問數據，即當前線程會阻塞，並等待 request的返回的response，而– initWithRequest:delegate:使用的是異步加載，當其完成網絡訪問後，會經過 delegate回到主線程，並其委託的對象。

五

試題1：

void test1()
{
char string[10];
char* str1 = 「0123456789」;
strcpy( string, str1 );
}
試題2：

void test2()
{
char string[10], str1[10];
int i;
for(i=0; i<10; i++)
{
str1 = ‘a';
}
strcpy( string, str1 );
}
試題3：

void test3(char* str1)
{
char string[10];
if( strlen( str1 ) <= 10 )
{
strcpy( string, str1 );
}
}
解答：

試題1字符串str1須要11個字節才能存放下（包括末尾的’\0’），而string只有10個字節的空間，strcpy會致使數組越界；

對試題2，若是面試者指出字符數組str1不能在數組內結束能夠給3分；若是面試者指出strcpy(string, str1)調用使得從str1[url=]內存[/url]起復制到string內存起所複製的字節數具備不肯定性能夠給7分，在此基礎上指出庫函數 strcpy工做方式的給10分；

對試題3，if(strlen(str1) <= 10)應改成if(strlen(str1) < 10)，由於strlen的結果未統計’\0’所佔用的1個字節。

剖析：

考查對基本功的掌握：

(1)字符串以’\0’結尾；

(2)對數組越界把握的敏感度；

(3)庫函數strcpy的工做方式，若是編寫一個標準strcpy函數的總分值爲10，下面給出幾個不一樣得分的答案：

2分

void strcpy( char *strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
4分

void strcpy( char *strDest, const char *strSrc )
//將源字符串加const，代表其爲輸入參數，加2分
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
7分

void strcpy(char *strDest, const char *strSrc)
{
//對源地址和目的地址加非0斷言，加3分
assert( (strDest != NULL) && (strSrc != NULL) );
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
10分

//爲了實現鏈式操做，將目的地址返回，加3分！

char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘\0’ );
return address;
}
從2分到10分的幾個答案咱們能夠清楚的看到，小小的strcpy居然暗藏着這麼多玄機，真不是蓋的！須要多麼紮實的基本功才能寫一個完美的strcpy啊！

(4)對strlen的掌握，它沒有包括字符串末尾的’\0’。

讀者看了不一樣分值的strcpy版本，應該也能夠寫出一個10分的strlen函數了，完美的版本爲： int strlen( const char *str ) //輸入參數const

{
assert( strt != NULL ); //斷言字符串地址非0
int len;
while( (*str++) != ‘\0′ )
{
len++;
}
return len;
}
試題4：

void GetMemory( char *p )
{
p = (char *) malloc( 100 );
}

void Test( void )
{
char *str = NULL;
GetMemory( str );
strcpy( str, 「hello world」 );
printf( str );
}
試題5：

char *GetMemory( void )
{
char p[] = 「hello world」;
return p;
}

void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
試題6：

void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}

void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, 「hello」 );
printf( str );
}
試題7：

void Test( void )
{
char *str = (char *) malloc( 100 );
strcpy( str, 「hello」 );
free( str );
… //省略的其它語句
}
解答：

試題4傳入中GetMemory( char *p )函數的形參爲字符串指針，在函數內部修改形參並不能真正的改變傳入形參的值，執行完

char *str = NULL;
GetMemory( str );
後的str仍然爲NULL；

試題5中

char p[] = 「hello world」;
return p;
的p[]數組爲函數內的局部自動變量，在函數返回後，內存已經被釋放。這是許多程序員常犯的錯誤，其根源在於不理解變量的生存期。

試題6的GetMemory避免了試題4的問題，傳入GetMemory的參數爲字符串指針的指針，可是在GetMemory中執行申請內存及賦值語句

*p = (char *) malloc( num );
後未判斷內存是否申請成功，應加上：

if ( *p == NULL )
{
…//進行申請內存失敗處理
}
試題7存在與試題6一樣的問題，在執行

char *str = (char *) malloc(100);
後未進行內存是否申請成功的判斷；另外，在free(str)後未置str爲空，致使可能變成一個「野」指針，應加上：

str = NULL;
試題6的Test函數中也未對malloc的內存進行釋放。

剖析：

試題4～7考查面試者對內存操做的理解程度，基本功紮實的面試者通常都能正確的回答其中50~60的錯誤。可是要徹底解答正確，卻也絕非易事。

對內存操做的考查主要集中在：

（1）指針的理解；

（2）變量的生存期及做用範圍；

（3）良好的動態內存申請和釋放習慣。

再看看下面的一段程序有什麼錯誤：

swap( int* p1,int* p2 )
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
在swap函數中，p是一個「野」指針，有可能指向系統區，致使程序運行的崩潰。在VC++中DEBUG運行時提示錯誤「Access Violation」。該程序應該改成：

swap( int* p1,int* p2 )
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}[img=12,12]file:///D:/魚魚軟件/魚魚多媒體日記本/temp/{56068A28-3D3B-4D8B-9F82- AC1C3E9B128C}_arc_d[1].gif[/img] 3.內功題　　試題1：分別給出BOOL，int，float，指針變量與「零值」比較的 if 語句（假設變量名爲var）

解答：

BOOL型變量：if(!var)

int型變量： if(var==0)

float型變量：

const float EPSINON = 0.00001;

if ((x >= – EPSINON) && (x <= EPSINON)

指針變量：　　if(var==NULL)

剖析：

考查對0值判斷的「內功」，BOOL型變量的0判斷徹底能夠寫成if(var==0)，而int型變量也能夠寫成if(!var)，指針變量的判斷也能夠寫成if(!var)，上述寫法雖然程序都能正確運行，可是未能清晰地表達程序的意思。
通常的，若是想讓if判斷一個變量的「真」、「假」，應直接使用if(var)、if(!var)，代表其爲「邏輯」判斷；若是用if判斷一個數值型變量 (short、int、long等)，應該用if(var==0)，代表是與0進行「數值」上的比較；而判斷指針則適宜用if(var==NULL)，這是一種很好的編程習慣。

浮點型變量並不精確，因此不可將float變量用「==」或「！=」與數字比較，應該設法轉化成「>=」或「<=」形式。若是寫成if (x == 0.0)，則判爲錯，得0分。

試題2：如下爲Windows NT下的32位C++程序，請計算sizeof的值

void Func ( char str[100] )
{
sizeof( str ) = ?
}

void *p = malloc( 100 );
sizeof ( p ) = ?
解答：

sizeof( str ) = 4
sizeof ( p ) = 4
剖析：

Func ( char str[100] )函數中數組名做爲函數形參時，在函數體內，數組名失去了自己的內涵，僅僅只是一個指針；在失去其內涵的同時，它還失去了其常量特性，能夠做自增、自減等操做，能夠被修改。

數組名的本質以下：

（1）數組名指代一種數據結構，這種數據結構就是數組；

例如：

char str[10];
cout ＜＜ sizeof(str) ＜＜ endl;
輸出結果爲10，str指代數據結構char[10]。

（2）數組名能夠轉換爲指向其指代實體的指針，並且是一個指針常量，不能做自增、自減等操做，不能被修改；

char str[10];
str++; //編譯出錯，提示str不是左值
（3）數組名做爲函數形參時，淪爲普通指針。

Windows NT 32位平臺下，指針的長度（佔用內存的大小）爲4字節，故sizeof( str ) 、sizeof ( p ) 都爲4。

試題3：寫一個「標準」宏MIN，這個宏輸入兩個參數並返回較小的一個。另外，當你寫下面的代碼時會發生什麼事？

least = MIN(*p++, b);
解答：

#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(*p++, b)會產生宏的反作用

剖析：

這個面試題主要考查面試者對宏定義的使用，宏定義能夠實現相似於函數的功能，可是它終歸不是函數，而宏定義中括弧中的「參數」也不是真的參數，在宏展開的時候對「參數」進行的是一對一的替換。

程序員對宏定義的使用要很是當心，特別要注意兩個問題：

（1）謹慎地將宏定義中的「參數」和整個宏用用括弧括起來。因此，嚴格地講，下述解答：

#define MIN(A,B) (A) <= (B) ? (A) : (B)
#define MIN(A,B) (A <= B ? A : B )
都應判0分；

（2）防止宏的反作用。

宏定義#define MIN(A,B) ((A) <= (B) ? (A) : (B))對MIN(*p++, b)的做用結果是：

((*p++) <= (b) ? (*p++) : (*p++))

這個表達式會產生反作用，指針p會做三次++自增操做。

除此以外，另外一個應該判0分的解答是：

#define MIN(A,B) ((A) <= (B) ? (A) : (B));
這個解答在宏定義的後面加「;」，顯示編寫者對宏的概念模糊不清，只能被無情地判0分並被面試官淘汰。

試題4：爲何標準頭文件都有相似如下的結構？

#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus

extern 「C」 {
#endif
/*…*/
#ifdef __cplusplus
}

#endif
#endif /* __INCvxWorksh */
解答：

頭文件中的編譯宏

#ifndef　__INCvxWorksh
#define　__INCvxWorksh
#endif
的做用是防止被重複引用。

做爲一種面向對象的語言，C++支持函數重載，而過程式語言C則不支持。函數被C++編譯後在symbol庫中的名字與C語言的不一樣。例如，假設某個函數的原型爲：

void foo(int x, int y);
該函數被C編譯器編譯後在symbol庫中的名字爲_foo，而C++編譯器則會產生像_foo_int_int之類的名字。_foo_int_int這樣的名字包含了函數名和函數參數數量及類型信息，C++就是考這種機制來實現函數重載的。

爲了實現C和C++的混合編程，C++提供了C鏈接交換指定符號extern 「C」來解決名字匹配問題，函數聲明前加上extern 「C」後，則編譯器就會按照C語言的方式將該函數編譯爲_foo，這樣C語言中就能夠調用C++的函數了。[img=12,12]file:///D:/魚魚軟件/魚魚多媒體日記本/temp/{C74A38C4-432E-4799-B54D-73E2CD3C5206}_arc_d[1].gif[/img]
試題5：編寫一個函數，做用是把一個char組成的字符串循環右移n個。好比原來是「abcdefghi」若是n=2，移位後應該是「hiabcdefgh」

函數頭是這樣的：

//pStr是指向以’\0’結尾的字符串的指針
//steps是要求移動的n

void LoopMove ( char * pStr, int steps )
{
//請填充…
}
解答：

正確解答1：

void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) – steps;
char tmp[MAX_LEN];
strcpy ( tmp, pStr + n );
strcpy ( tmp + steps, pStr);
*( tmp + strlen ( pStr ) ) = ‘\0′;
strcpy( pStr, tmp );
}
正確解答2：

void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) – steps;
char tmp[MAX_LEN];
memcpy( tmp, pStr + n, steps );
memcpy(pStr + steps, pStr, n );
memcpy(pStr, tmp, steps );
}
剖析：

這個試題主要考查面試者對標準庫函數的熟練程度，在須要的時候引用庫函數能夠很大程度上簡化程序編寫的工做量。

最頻繁被使用的庫函數包括：

（1） strcpy

（2） memcpy

（3） memset

六

1.Difference between shallow copy and deep copy?
答案：淺複製和深複製的區別？
答案：淺層複製：只複製指向對象的指針，而不復制引用對象自己。
深層複製：複製引用對象自己。
意思就是說我有個A對象，複製一份後獲得A_copy對象後，對於淺複製來講，A和A_copy指向的是同一個內存資源，複製的只不過是是一個指針，對象自己資源
仍是隻有一份，那若是咱們對A_copy執行了修改操做,那麼發現A引用的對象一樣被修改，這其實違背了咱們複製拷貝的一個思想。深複製就好理解了,內存中存在了
兩份獨立對象自己。
用網上一哥們通俗的話將就是：
淺複製比如你和你的影子，你完蛋，你的影子也完蛋
深複製比如你和你的克隆人，你完蛋，你的克隆人還活着。

2.What is advantage of categories? What is difference between implementing a category and inheritance?
答案：類別的做用？繼承和類別在實現中有何區別？
答案：category 能夠在不獲悉，不改變原來代碼的狀況下往裏面添加新的方法，只能添加，不能刪除修改。
而且若是類別和原來類中的方法產生名稱衝突，則類別將覆蓋原來的方法，由於類別具備更高的優先級。
類別主要有3個做用：
(1)將類的實現分散到多個不一樣文件或多個不一樣框架中。
(2)建立對私有方法的前向引用。
(3)向對象添加非正式協議。
繼承能夠增長，修改或者刪除方法，而且能夠增長屬性。

3.Difference between categories and extensions?類別和類擴展的區別。
答案：category和extensions的不一樣在於後者能夠添加屬性。另外後者添加的方法是必需要實現的。
extensions能夠認爲是一個私有的Category。

4.Difference between protocol in objective c and interfaces in java?oc中的協議和java中的接口概念有何不一樣？
答案：OC中的代理有2層含義，官方定義爲 formal和informal protocol。前者和Java接口同樣。
informal protocol中的方法屬於設計模式考慮範疇，不是必須實現的，可是若是有實現，就會改變類的屬性。
其實關於正式協議，類別和非正式協議我很早前學習的時候大體看過，也寫在了學習教程裏
「非正式協議概念其實就是類別的另外一種表達方式「這裏有一些你可能但願實現的方法，你能夠使用他們更好的完成工做」。
這個意思是，這些是可選的。好比我門要一個更好的方法，咱們就會申明一個這樣的類別去實現。而後你在後期能夠直接使用這些更好的方法。
這麼看，總以爲類別這玩意兒有點像協議的可選協議。」
如今來看，其實protocal已經開始對二者都統一和規範起來操做，由於資料中說「非正式協議使用interface修飾「，
如今咱們看到協議中兩個修飾詞：「必須實現(@requied)」和「可選實現(@optional)」。

5.What are KVO and KVC?
答案：kvc:鍵 – 值編碼是一種間接訪問對象的屬性使用字符串來標識屬性，而不是經過調用存取方法，直接或經過實例變量訪問的機制。
不少狀況下能夠簡化程序代碼。apple文檔其實給了一個很好的例子。
kvo:鍵值觀察機制，他提供了觀察某一屬性變化的方法，極大的簡化了代碼。
具體用看到嗯哼用到過的一個地方是對於按鈕點擊變化狀態的的監控。
好比我自定義的一個button
[cpp]
[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];
}
}
對於系統是根據keypath去取的到相應的值發生改變，理論上來講是和kvc機制的道理是同樣的。
對於kvc機制如何經過key尋找到value：
「當經過KVC調用對象時，好比：[self valueForKey:@」someKey」]時，程序會自動試圖經過幾種不一樣的方式解析這個調用。首先查找對象是否帶有 someKey 這個方法，若是沒找到，會繼續查找對象是否帶有someKey這個實例變量（iVar），若是尚未找到，程序會繼續試圖調用 -(id) valueForUndefinedKey:這個方法。若是這個方法仍是沒有被實現的話，程序會拋出一個NSUndefinedKeyException 異常錯誤。
(cocoachina.com注：Key-Value Coding查找方法的時候，不只僅會查找someKey這個方法，還會查找getsomeKey這個方法，前面加一個get，或者_someKey以及 _getsomeKey這幾種形式。同時，查找實例變量的時候也會不只僅查找someKey這個變量，也會查找_someKey這個變量是否存在。）
設計valueForUndefinedKey:方法的主要目的是當你使用-(id)valueForKey方法從對象中請求值時，對象可以在錯誤發生前，有最後的機會響應這個請求。這樣作有不少好處，下面的兩個例子說明了這樣作的好處。「
來至cocoa，這個說法應該挺有道理。
由於咱們知道button倒是存在一個highlighted實例變量.所以爲什麼上面咱們只是add一個相關的keypath就好了，

6.What is purpose of delegates?代理的做用？
答案：代理的目的是改變或傳遞控制鏈。容許一個類在某些特定時刻通知到其餘類，而不須要獲取到那些類的指針。能夠減小框架複雜度。
另一點，代理能夠理解爲java中的回調監聽機制的一種相似。

7.What are mutable and immutable types in Objective C?oc中可修改和不能夠修改類型。
答案：可修改不可修改的集合類。這個我我的簡單理解就是可動態添加修改和不可動態添加修改同樣。
好比NSArray和NSMutableArray。前者在初始化後的內存控件就是固定不可變的，後者能夠添加等，能夠動態申請新的內存空間

8.When we call objective c is runtime language what does it mean?咱們說的oc是動態運行時語言是什麼意思？
答案：多態。主要是將數據類型的肯定由編譯時，推遲到了運行時。
這個問題其實淺涉及到兩個概念，運行時和多態。
簡單來講，運行時機制使咱們直到運行時纔去決定一個對象的類別，以及調用該類別對象指定方法。
多態：不一樣對象以本身的方式響應相同的消息的能力叫作多態。意思就是假設生物類（life）都用有一個相同的方法-eat;
那人類屬於生物，豬也屬於生物，都繼承了life後，實現各自的eat，可是調用是咱們只需調用各自的eat方法。
也就是不一樣的對象以本身的方式響應了相同的消息（響應了eat這個選擇器）。
所以也能夠說，運行時機制是多態的基礎？~~~

9.what is difference between NSNotification and protocol?通知和協議的不一樣之處？
答案：協議有控制鏈(has-a)的關係，通知沒有。
首先我一開始也不太明白，什麼叫控制鏈（專業術語了~）。可是簡單分析下通知和代理的行爲模式，咱們大體能夠有本身的理解
簡單來講，通知的話，它能夠一對多，一條消息能夠發送給多個消息接受者。
代理按咱們的理解，到不是直接說不能一對多，好比咱們知道的明星經濟代理人，不少時候一個經濟人負責好幾個明星的事務。
只是對於不一樣明星間，代理的事物對象都是不同的，一一對應，不可能說明天要處理A明星要一個發佈會，代理人發出處理髮佈會的消息後，別稱B的
發佈會了。可是通知就不同，他只關心發出通知，而不關心多少接收到感興趣要處理。
所以控制鏈（has-a從英語單詞大體能夠看出，單一擁有和可控制的對應關係。

10.What is push notification?什麼是推送消息？
答案：太簡單，不做答~~~~~~~~~~
這是cocoa上的答案。
其實到不是說太簡單，只是太泛泛的一個概念的東西。就比如說，什麼是人。
推送通知更是一種技術。
簡單點就是客戶端獲取資源的一種手段。
普通狀況下，都是客戶端主動的pull。
推送則是服務器端主動push。

12.What is responder chain?
說說響應鏈
答案：事件響應鏈。包括點擊事件，畫面刷新事件等。在視圖棧內從上至下，或者從下之上傳播。
能夠說點事件的分發，傳遞以及處理。具體能夠去看下touch事件這塊。由於問的太抽象化了
嚴重懷疑題目出到越後面就越籠統。

13.Difference between frame and bounds?
frame和bounds有什麼不一樣？
答案:frame指的是：該view在父view座標系統中的位置和大小。（參照點是父親的座標系統）
bounds指的是：該view在自己座標系統中的位置和大小。（參照點是自己座標系統）

14.Difference between method and selector?
方法和選擇器有何不一樣？
答案：selector是一個方法的名字，method是一個組合體，包含了名字和實現.

15.NSOperation queue?
答案：存放NSOperation的集合類。
操做和操做隊列，基本能夠當作java中的線程和線程池的概念。用於處理ios多線程開發的問題。
網上部分資料提到一點是，雖然是queue，可是卻並非帶有隊列的概念，放入的操做並不是是按照嚴格的先進現出。
這邊又有個疑點是，對於隊列來講，先進先出的概念是Afunc添加進隊列，Bfunc緊跟着也進入隊列，Afunc先執行這個是必然的，
可是Bfunc是等Afunc徹底操做完之後，B纔開始啓動而且執行，所以隊列的概念離亂上有點違背了多線程處理這個概念。
可是轉念一想其實能夠參考銀行的取票和叫號系統。
所以對於A比B先排隊取票可是B率先執行完操做，咱們亦然能夠感性認爲這仍是一個隊列。
可是後來看到一票關於這操做隊列話題的文章，其中有一句提到
「由於兩個操做提交的時間間隔很近，線程池中的線程，誰先啓動是不定的。」
瞬間以爲這個queue名字有點忽悠人了，還不如pool~
綜合一點，咱們知道他能夠比較大的用處在於能夠幫組多線程編程就行了。

16.What is lazy loading?
答案：懶漢模式，只在用到的時候纔去初始化。
也能夠理解成延時加載。
我以爲最好也最簡單的一個列子就是tableView中圖片的加載顯示了。
一個延時載，避免內存太高，一個異步加載，避免線程堵塞。

17.Can we use two tableview controllers on one viewcontroller?
是否在一個視圖控制器中嵌入兩個tableview控制器？
答案：一個視圖控制只提供了一個View視圖，理論上一個tableViewController也不能放吧，
只能說能夠嵌入一個tableview視圖。固然，題目自己也有歧義，若是不是咱們定性思惟認爲的UIViewController，
而是宏觀的表示視圖控制者，那咱們卻是能夠把其當作一個視圖控制者，它能夠控制多個視圖控制器，好比TabbarController
那樣的感受。

18.Can we use one tableview with two different datasources? How you will achieve this?
一個tableView是否能夠關聯兩個不一樣的數據源？你會怎麼處理？
答案：首先咱們從代碼來看，數據源如何關聯上的，實際上是在數據源關聯的代理方法裏實現的。
所以咱們並不關心如何去關聯他，他怎麼關聯上，方法只是讓我返回根據本身的須要去設置如相關的數據源。
所以，我以爲能夠設置多個數據源啊，可是有個問題是，你這是想幹嗎呢？想讓列表如何顯示，不一樣的數據源分區塊顯示？

七

1.請寫一個C函數，若處理器是Big_endian的，則返回0；如果Little_endian的，則返回1 int checkCPU( ) {
{
union w
{
int a;
char b;
} c;
c.a = 1;
return (c.b ==1);
}
}
答案：嵌入式系統開發者應該對Little-endian和Big-endian模式很是瞭解。採用Little-endian模式的CPU對操做數的存放方式是從低字節到高字節， Big-endian 模式的CPU對操做數的存放方式是從高字節到低字節。在弄清楚這個以前要弄清楚這個問題：字節從右到坐爲從高到低! 假設從地址0x4000開始存放: 0x12345678,是也個32位四個字節的數據，最高字節是0x12,最低字節是0x78：在Little-endian模式CPU內存中的存放方式爲： (高字節在高地址, 低字節在低地址)
內存地址0x4000 0x4001 0x4002 0x4003
存放內容 0x78 0x56 0x34 0x12
大端機則相反。

有的處理器系統採用了小端方式進行數據存放，如Intel的奔騰。有的處理器系統採用了大端方式進行數據存放，如IBM半導體和Freescale的PowerPC處理器。不只對於處理器，一些外設的設計中也存在着使用大端或者小端進行數據存放的選擇。所以在一個處理器系統中，有可能存在大端和小端模式同時存在的現象。這一現象爲系統的軟硬件設計帶來了不小的麻煩，這要求系統設計工程師，必須深刻理解大端和小端模式的差異。大端與小端模式的差異體如今一個處理器的寄存器，指令集，系統總線等各個層次中。聯合體union的存放順序是全部成員都從低地址開始存放的。以上是網上的原文。讓咱們看看在ARM處理器上union是如何存儲的呢? 地址A —————- |A |A+1 |A+2 |A+3 |int a; | | | | ——————– |A |char b; | | ——— 若是是小端如何存儲c.a的呢？
地址A ———–
——————- |A |A+1 |A+2 |A+3 | int a;
|0x01 |0x00 |0x00 |0x00 | ————————————- |A |char b; | | ———
若是是大端如何存儲c.a的呢？
地址A ———————
——— |A |A+1 |A+2 |A+3 |int a; |0x00 |0x00 |0x00 |0x01 | —————————————— |A |char b; | | ——— 如今知道爲何c.b==0的話是大端，c.b==1的話就是小端了吧。

2.堆和棧上的指針
答案：指針所指向的這塊內存是在哪裏分配的,在堆上稱爲堆上的指針,在棧上爲棧上的指針.
在堆上的指針,能夠保存在全局數據結構中,供不一樣函數使用訪問同一塊內存.
在棧上的指針,在函數退出後,該內存即不可訪問.

3.什麼是指針的釋放?
答案：具體來講包括兩個概念.
1 釋放該指針指向的內存,只有堆上的內存才須要咱們手工釋放,棧上不須要.
2 將該指針重定向爲NULL.

4.數據結構中的指針?
答案：其實就是指向一塊內存的地址,經過指針傳遞,可實現複雜的內存訪問.

5.函數指針?
答案：指向一塊函數的入口地址.

6.指針做爲函數的參數?
答案：好比指向一個複雜數據結構的指針做爲函數變量
這種方法避免整個複雜數據類型內存的壓棧出棧操做,提升效率.
注意:指針自己不可變,但指針指向的數據結構能夠改變.

7.指向指針的指針?
答案：指針指向的變量是一個指針,即具體內容爲一個指針的值,是一個地址.
此時指針指向的變量長度也是4位.

8.指針與地址的區別?
答案：區別:
1指針意味着已經有一個指針變量存在,他的值是一個地址,指針變量自己也存放在一個長度爲四個字節的地址當中,而地址概念自己並不表明有任何變量存在.
2 指針的值,若是沒有限制,一般是能夠變化的,也能夠指向另一個地址.
地址表示內存空間的一個位置點,他是用來賦給指針的,地址自己是沒有大小概念,指針指向變量的大小,取決於地址後面存放的變量類型.

9.指針與數組名的關係?
答案：其值都是一個地址,但前者是能夠移動的,後者是不可變的.

10.怎樣防止指針的越界使用問題?
答案：必須讓指針指向一個有效的內存地址,
1 防止數組越界
2 防止向一塊內存中拷貝過多的內容
3 防止使用空指針
4 防止改變const修改的指針
5 防止改變指向靜態存儲區的內容
6 防止兩次釋放一個指針
7 防止使用野指針.
11.指針的類型轉換?
答案：指針轉換一般是指針類型和void * 類型以前進行強制轉換,從而與指望或返回void指針的函數進行正確的交接.

12.static有什麼用途？（請至少說明兩種）
答案：1.限制變量的做用域
2.設置變量的存儲域

13.引用與指針有什麼區別？
答案： 1) 引用必須被初始化，指針沒必要。
2) 引用初始化之後不能被改變，指針能夠改變所指的對象。
3) 不存在指向空值的引用，可是存在指向空值的指針。

14.描述實時系統的基本特性
答案：在特定時間內完成特定的任務，實時性與可靠性

15.全局變量和局部變量在內存中是否有區別？若是有，是什麼區別？
答案：全局變量儲存在靜態數據庫，局部變量在堆棧

16.什麼是平衡二叉樹？
答案：左右子樹都是平衡二叉樹且左右子樹的深度差值的絕對值不大於1

17.堆棧溢出通常是由什麼緣由致使的？
答案：沒有回收垃圾資源

18.什麼函數不能聲明爲虛函數？
答案：constructor

19. 冒泡排序算法的時間複雜度是什麼？
答案：O(n^2)

20. 寫出float x 與「零值」比較的if語句。
答案：if(x>0.000001&&x<-0.000001)

21. Internet採用哪一種網絡協議？該協議的主要層次結構？
答案：tcp/ip 應用層/傳輸層/網絡層/數據鏈路層/物理層

22. Internet物理地址和IP地址轉換採用什麼協議？
答案：ARP (Address Resolution Protocol)（地址解析協議）

八

一、請看下面一段代碼

static int a = 1;
int main(){
int b = 2;
char *c = NULL;
c = (char *)malloc(100 * sizeof(char));
return 0;
}
請問訪問a,b,c 3種類型變量的效率從高到低依次是（B）
A. cba
B. abc
C. acb
D. bca

二、下面四種內部排序算法中哪種在最差狀況下時間複雜度最高？（B）
A. 快速排序
B. 冒泡排序
C. 堆排序
D. 歸併排序

三、Shell中，將command1的輸出做爲command2的輸入應該使用的命令是（D）
A. command1 && command2
B. command1 > command2
C. command1 & command2
D. command1 | command2

四、下面的數據結構中不屬於線性結構的是（C）
A. 棧
B. 鏈表
C. 二叉樹
D. 線性表

五、在一個二叉樹上，第5層最多能夠有的節點數是（C）
A. 2
B. 8
C. 16
D. 32

六、在長度爲n的線性表上進行順序查找，在最糟糕的狀況下須要的比較次數是（A）
A. n
B. 2n-1
C. 2n
D. n^2

七、下面那項不是動態語言的特性（B）
A. 在運行時替換一個類
B. 在運行時動態加載lib文件
C. 在運行時修改對象中的方法
D. 在運行時增長對象的方法

八、已知二叉樹後序遍歷序列是dabec，中序遍歷序列是debac，它的前序遍歷序列是（A）
A. cedba
B. acbed
C. decab
D. deabc

九、如下多線程對int型變量x的操做，哪一個不須要進行同步：（D）
A. x=y
B. x++
C. ++x
D. x=1

十、多線程中棧與堆是公有的仍是私有的（C）
A. 棧公有, 堆私有
B. 棧公有，堆公有
C. 棧私有, 堆公有
D. 棧私有，堆私有

十一、在Xcode中，須要編譯混合Objective-C和C++的源碼文件，須要將文件格式的後綴改成（C）
A. .c
B. .cpp
C. .mm
D. .m

十二、Objective-C聲明一個類所要用到的編譯指令是（A）
A. @interface SomeClass
B. @protocol SomeClass
C. @implementation SomeClass
D. @autorelease SomeClass

1三、使用Xcode建立工程時，支持同時建立的版本管理庫是（C）
A. Subversion
B. Mercurial
C. Git
D. Concurrent Versions System

1四、下面那個方法不屬於NSObject的內省（Introspection）方法（A）
A. init
B. isKindOfClass
C. responseToSelector
D. isMemberOfClass

1五、使用protocol時，聲明一組可選擇實現與否的函數，須要在聲明的前一行加上：（B）
A. @required
B. @optional
C. @interface
D. @protocol

1六、須要在手動管理內存分配和釋放的Xcode項目中引入和編譯用ARC風格編寫的文件，須要在文件的Compiler Flags上添加參數：（C）
A. -shared
B. -fno-objc-arc
C. -fobjc-arc
D. -dynamic

1七、下面關於Objective-C內存管理的描述錯誤的是（A）
A. 當使用ARC來管理內存時，代碼中不能夠出現autorelease
B. autoreleasepool 在 drain 的時候會釋放在其中分配的對象
C. 當使用ARC來管理內存時，在線程中大量分配對象而不用autoreleasepool則可能會形成內存泄露
D. 在使用ARC的項目中不能使用NSZone

1八、下面關於#import和#include的描述正確的是（A）
A. #import 是 #include 的替代指令，防止重複引用
B. #import 和 #include 不能夠混合使用
C. #import 只用於引用 Objective-C的文件， #include 只用於引用C和C++的文件
D. #import 和 #include 的使用效果徹底相同

1九、下面的代碼問題在哪？（B）

@implementation xxx
…
…
– (void) setVar:(int)i {
self.var = i;
}
A. 應該將var synthesize
B. 調用會出現死循環
C. 正常
D. 返回值錯誤

20、下面那個方法能夠比較兩個NSString *str1, *str2 的異同（B）
A. if(str1 = str2) xxx ;
B. if([str1 isEqualToString:str2]) xxx ;
C. if(str1 && str2) xxx ;
D. if([str1 length] == [str2 length]) xxx;

2一、下面哪一個不屬於對象數據序列化方法（D）
A. JSON
B. Property List
C. XML
D. HTTP

2二、在UIKit中，frame與bounds的區別是（C）
A. frame 是 bounds 的別名
B. frame 是 bounds 的繼承類
C. frame 的參考系是父視圖座標，bounds 的參考系是自身的座標
D. frame 的參考系是自身座標，bounds 的參考系是父視圖的座標

2三、Objective-C有私有方法嗎？有私有變量嗎？（C）
A. 有私有方法和私有變量
B. 沒有私有方法也沒有私有變量
C. 沒有私有方法，有私有變量
D. 有私有方法，沒有私有變量

2四、下面關於線程管理錯誤的是（B）
A. GCD所用的開銷要比NSThread大
B. 能夠在子線程中修改UI元素
C. NSOperationQueue是比NSthread更高層的封裝
D. GCD能夠根據不一樣優先級分配線程

2五、下面代碼的做用是讓doSomeThing函數每隔1秒被調用1次。請問哪裏有問題（A）

NSTimer *myTimer = [NSTimer timerWithTimeInterval:1.0 target:self selector:@selector(doSomeThing:) userInfo:nil repeats:YES];

[myTimer fire]
A. 沒有將timer加入runloop
B. doSomeThing缺乏參數
C. 忘記傳遞數據給userInfo
D. myTimer對象未經過[[myTimer alloc] init]方法初始化

2六、UIViewController在顯示過程當中，各個方法的調用順序是（A）
A. init -> viewDidLoad -> viewDidAppear -> viewDidUnload
B. init -> viewDidAppear -> viewDidLoad -> viewDidUnload
C. init -> viewDidLoad -> viewDidUnload -> viewDidAppear
D. init -> viewDidAppear -> viewDidUnload -> viewDidLoad

2七、使用imageNamed方法建立UIImage對象時，與普通的init方法有什麼區別？（C）
A. 沒有區別，只是爲了方便
B. imageNamed方法只是建立了一個指針，沒有分配其餘內存
C. imageNamed方法將圖片加載到內存中後再也不釋放
D. imageNamed方法將使用完圖片後當即釋放

2八、一個類的delegate（代理）的做用不正確的是（D）
A. delegate中的函數在其餘類中實現
B. 主要用於不一樣類型的對象之間一對一傳遞消息
C. 沒有指派則不會觸發
D. 能夠一個對象的delegate指派給多個其餘類型的對象

2九、在沒有navigationController的狀況下，要從一個ViewController切換到另外一個ViewController應該（D）
A. [self.navigationController pushViewController:nextViewController animated:YES];
B. [self.view addSubview:nextViewController.view];
C. [self pushViewController:nextViewController animated:YES];
D. [self presentModalViewController:nextViewController animated:YES];

30、什麼是key window？（C）A. App中惟一的那個UIWindow對象B. 能夠指定一個key的UIWindowC. 可接收到鍵盤輸入等事件的UIWindowD. 不能夠隱藏的那個UIWindow對象