ios面試題彙總

時間 2019-11-12

標籤 ios 面試彙總欄目 iOS 简体版

原文原文鏈接

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

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

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

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

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就好了， 能夠按照kvc查找的邏輯理解，就說的過去了。程序員

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

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

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

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

10.What is push notification? 什麼是推送消息？ sql

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.? OBC的垃圾回收機制？ 
答案： OBC2.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~ 綜合一點，咱們知道他能夠比較大的用處在於能夠幫組多線程編程就行了。

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是否能夠關聯兩個不一樣的數據源？你會怎麼處理？ 
答案：首先咱們從代碼來看，數據源如何關聯上的，實際上是在數據源關聯的代理方法裏實現的。 所以咱們並不關心如何去關聯他，他怎麼關聯上，方法只是讓我返回根據本身的須要去設置如相關的數據源。 所以，我以爲能夠設置多個數據源啊，可是有個問題是，你這是想幹嗎呢？想讓列表如何顯示，不一樣的數據源分區塊顯示？

21.Object－c的類能夠多重繼承麼？能夠實現多個接口麼？重寫一個類的方式用繼承好仍是分類好？爲何？
Objective-c只支持單繼承，若是要實現多繼承的話，能夠經過類別和協議的方式來實現，cocoa 中全部的類都是NSObject 的子類，多繼承在這裏是用protocol 委託代理來實現的。

22.#import 跟#include 又什麼區別＃import<> 跟 #import""又什麼區別？
答案：@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import而#import比起#include的好處就是不會引發交叉編譯。

23.類變量的@protected ,@private,@public,@package聲明各有什麼含義？

24.id 聲明的對象有什麼特性？
答案：id是個很重要的類型，是個能夠指向任何類型的指針或者能夠理解爲指向任何未知類型的指針。

25.MVC是什麼？有什麼特性？爲何在iPhone上被普遍運用？
答案：MVC設計模式考慮三種對象：模型對象、視圖對象、和控制器對象。模型對象表明特別的知識和專業技能，它們負責保有應用程序的數據和定義操做數據的邏輯。視圖對象知道如何顯示應用程序的模型數據，並且可能容許用戶對其進行編輯。控制器對象是應用程序的視圖對象和模型對象之間的協調者。

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

27.什麼是安全釋放？

28.爲何有些4.0獨有的objective－c 函數在3.1上運行時會報錯.而4.0獨有的類在3.1上分配內存時不會報錯？分配的結果是什麼？

29.爲何4.0獨有的c函數在3.1的機器上運行不會報錯（在沒有調用的狀況下？）而4.0獨有的類名在3.1的機器上一運行就報錯？

30.異常exception 怎麼捕獲？不一樣的CPU結構上開銷怎樣？C中又什麼相似的方法？

31.property中屬性retain,copy,assgin的含義分別是什麼？有什麼區別？將其轉換成get／set方法怎麼作？有什麼注意事項？

32.委託是什麼？委託的property聲明用什麼屬性？爲何？

34.Cocoa中有虛基類的概念麼？怎麼簡潔的實現？

35.自動釋放池跟GC（垃圾回收）有什麼區別？iPhone上有GC麼？［pool release］和［pool drain］有什麼區別？
iPhone上沒有GC。iPhone開發的時候沒有垃圾回收機制。
在垃圾回收環境中，release是一個空操做。所以，NSAutoreleasePool提供了drain方法，在引用計數環境中，該方法的做用等同於調用release，但在垃圾回收環境中，它會觸發垃圾回收（若是自上次垃圾回收以來分配的內存大於當前的閾值）。所以，在一般狀況下，您應該使用drain而不是release來銷燬自動釋放池。

36.
for(int index = 0; index < 20; index ++){
NSString *tempStr = @」tempStr」;
NSLog(tempStr);
NSNumber *tempNumber = [NSNumber numberWithInt:2];
NSLog(tempNumber);
}
這段代碼有什麼問題.？會不會形成內存泄露（多線程）？在內存緊張的設備上作大循環時自動釋放池是寫在循環內好仍是循環外好？爲何？

37.內存管理的幾條原則時什麼？按照默認法則.那些關鍵字生成的對象須要手動釋放？在和property結合的時候怎樣有效的避免內存泄露？

38.在一個對象釋放前.若是他被加到了notificationCenter 中.不在notificationcenter中remove這個對象可能會出現什麼問題？

39.怎樣實現一個 singleton的類.給出思路。

40.什麼是序列化或者Acrchiving,能夠用來作什麼,怎樣與copy結合,原理是什麼?.

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

42.在iphone上有兩件事情要作,請問是在一個線程裏按順序作效率高仍是兩個線程裏作效率高？爲何？

43.runloop是什麼？在主線程中的某個函數裏調用了異步函數，怎麼樣block當前線程,且還能響應當前線程的timer事件，touch事件等.

44.ios平臺怎麼作數據的持久化?coredata和sqlite有無必然聯繫？coredata是一個關係型數據庫嗎？
iOS中能夠有四種持久化數據的方式：屬性列表、對象歸檔、SQLite3和Core Data；core data能夠使你以圖形界面的方式快速的定義app的數據模型，同時在你的代碼中容易獲取到它。core data提供了基礎結構去處理經常使用的功能，例如保存，恢復，撤銷和重作，容許你在app中繼續建立新的任務。在使用core data的時候，你不用安裝額外的數據庫系統，由於core data使用內置的sqlite數據庫。core data將你app的模型層放入到一組定義在內存中的數據對象。core data會追蹤這些對象的改變，同時能夠根據須要作相反的改變，例如用戶執行撤銷命令。當core data在對你app數據的改變進行保存的時候，core data會把這些數據歸檔，並永久性保存。
mac os x中sqlite庫，它是一個輕量級功能強大的關係數據引擎，也很容易嵌入到應用程序。能夠在多個平臺使用，sqlite是一個輕量級的嵌入式sql數據庫編程。與core data框架不一樣的是，sqlite是使用程序式的，sql的主要的API來直接操做數據表。
Core Data不是一個關係型數據庫，也不是關係型數據庫管理系統(RDBMS)。雖然Core Dta支持SQLite做爲一種存儲類型，但它不能使用任意的SQLite數據庫。Core Data在使用的過程種本身建立這個數據庫。Core Data支持對1、對多的關係。

45.闡述一個nil對象從interface bulider產生，到載入程序運行空間，最後被釋放時所經歷的生命週期.

46.notification是同步仍是異步? kvo是同步仍是異步？notification是全進程空間的通知嗎？kvo呢？

~~47.kvc是什麼?kvo是什麼?有什麼特性？~~

~~48.響應者鏈是什麼？~~

49.unix上進程怎麼通訊？

UNIX主要支持三種通訊方式：

1. 基本通訊：主要用來協調進程間的同步和互斥

(1)鎖文件通訊

通訊的雙方經過查找特定目錄下特定類型的文件(稱鎖文件)來完成進程間對臨界資源訪問時的互斥；例如進程p1訪問一個臨界資源，首先查看是否有一個特定類型文件，如有，則等待一段時間再查找鎖文件。

(2)記錄鎖文件

2. 管道通訊：適應大批量的數據傳遞

3. IPC ：適應大批量的數據傳遞

50.timer的間隔週期準嗎？爲何？怎樣實現一個精準的timer?

51.UIscrollVew用到了什麼設計模式？還能再foundation庫中找到相似的嗎？（答案衆多，不知道哪一個是對的～～）

模板(Template)模式，全部datasource和delegate接口都是模板模式的典型應用，

組合模式composition，全部的containerview都用了這個模式

觀察者模式observer，全部的UIResponder都用了這個模式。

52若是要開發一個相似eclipse的軟件，支持插件結構。且開放給第三方開發。你會怎樣去設計它？（大概思路）

53. main()

{

int a[5]={1,2,3,4,5};

int *ptr=(int *)(&a+1);

printf("%d,%d",*(a+1),*(ptr-1));

}

答：2,5

*(a+1)就是a[1]，*(ptr-1)就是a[4],執行結果是2.5 ，&a+1不是首地址+1，系統會認爲加一個a數組的偏移，是偏移了一個數組的大小（本例是5個int，int *ptr=(int *)(&a+1); 則ptr實際是&(a[5]),也就是a+5 緣由以下：

　　&a是數組指針，其類型爲 int (*)[5]; 而指針加1要根據指針類型加上必定的值，不一樣類型的指針+1以後增長的大小不一樣。a是長度爲5的int數組指針，因此要加 5*sizeof(int)因此ptr實際是a[5]，可是prt與(&a+1)類型是不同的(這點很重要)，因此prt-1只會減去sizeof(int*)，a,&a的地址是同樣的，但意思不同，a是數組首地址，也就是a[0]的地址，&a是對象（數組）首地址，a+1是數組下一元素的地址，即a[1],&a+1是下一個對象的地址，即a[5].

54. 如下爲Windows NT下的32位C++程序，請計算sizeof的值  voidFunc ( char str[100] )  {   sizeof( str ) =?  }  void *p = malloc( 100 );  sizeof ( p ) = ?

答案：這題很常見了,Func( char str[100] )函數中數組名做爲函數形參時，在函數體內，數組名失去了自己的內涵，僅僅只是一個指針；在失去其內涵的同時，它還失去了其常量特性，能夠做自增、自減等操做，能夠被修改。Windows NT 32位平臺下，指針的長度（佔用內存的大小）爲4字節，故sizeof( str ) 、sizeof( p ) 都爲4。

55.- （void）*getNSString(const NSString *inputString)

{ inputString =@"This is a main test\n";

return ;}

-main(void)

{NSString *a=@"Main";

NSString *aString = [NSStringstringWithString:@"%@",getNSString(a)];

NSLog(@"%@\n", aString);}

最後問輸出的字符串:NULL,output在函數返回後，內存已經被釋放。

56.列舉幾種進程的同步機制，並比較其優缺點。

答案：原子操做信號量機制自旋鎖管程，會合，分佈式系統  

進程之間通訊的途徑

答案：共享存儲系統消息傳遞系統管道：以文件系統爲基礎

進程死鎖的緣由

答案：資源競爭及進程推動順序非法

死鎖的4個必要條件

答案：互斥、請求保持、不可剝奪、環路

死鎖的處理

答案：鴕鳥策略、預防策略、避免策略、檢測與解除死鎖

57.堆和棧的區別

管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。

申請大小： 棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。所以，能從棧得到的空間較小。 堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。

碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出

分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。

分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。

58.什麼是鍵-值,鍵路徑是什麼?

模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。

鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的 性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型 實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相 關對象的特定屬性。

59.c和obj-c如何混用

1）obj-c的編譯器處理後綴爲m的文件時，能夠識別obj-c和c的代碼，處理mm文件能夠識別obj-c,c,c++代碼，但cpp文件必須只能用c/c++代碼，並且cpp文件include的頭文件中，也不能出現obj- c的代碼，由於cpp只是cpp 2) 在mm文件中混用cpp直接使用便可，因此obj-c混cpp不是問題 3）在cpp中混用obj- c其實就是使用obj-c編寫的模塊是咱們想要的。 若是模塊以類實現，那麼要按照cpp class的標準寫類的定義，頭文件中不能出現obj-c的東西，包括#import cocoa的。實現文件中，即類的實現代碼中能夠使用obj-c的東西，能夠import,只是後綴是mm。 若是模塊以函數實現，那麼頭文件要按 c的格式聲明函數，實現文件中，c++函數內部能夠用obj-c，但後綴仍是mm或m。  總結：只要cpp文件和cpp include的文件中不包含obj-c的東西就能夠用了，cpp混用obj-c的關鍵是使用接口，而不能直接使用實現代碼，實際上cpp混用的是 obj-c編譯後的o文件，這個東西實際上是無差異的，因此能夠用。obj-c的編譯器支持cpp.

60.目標-動做機制

目標是動做消息的接收者。一個控件，或者更爲常見的是它的單元，以插座變量（參見"插座變量"部分） 的形式保有其動做消息的目標。

動做是控件發送給目標的消息，或者從目標的角度看，它是目標爲了響應動做而實現的方法。

程序須要某些機制來進行事件和指令的翻譯。這個機制就是目標-動做機制。

61.cocoatouch框架

iPhoneOS 應用程序的基礎Cocoa Touch 框架重用了許多 Mac 系統的成熟模式，可是它更多地專一於觸摸的接口和優化。UIKit 爲您提供了在 iPhone OS 上實現圖形，事件驅動程序的基本工具，其創建在和 Mac OS X 中同樣的 Foundation 框架上，包括文件處理，網絡，字符串操做等。

CocoaTouch 具備和 iPhone 用戶接口一致的特殊設計。有了 UIKit，您能夠使用 iPhone OS 上的獨特的圖形接口控件，按鈕，以及全屏視圖的功能，您還能夠使用加速儀和多點觸摸手勢來控制您的應用。

各色俱全的框架除了UIKit 外，Cocoa Touch 包含了建立世界一流iPhone 應用程序須要的全部框架，從三維圖形，到專業音效，甚至提供設備訪問 API 以控制攝像頭，或經過 GPS 獲知當前位置。Cocoa Touch 既包含只須要幾行代碼就能夠完成所有任務的強大的 Objective-C 框架，也在須要時提供基礎的 C 語言 API 來直接訪問系統。這些框架包括：

CoreAnimation

經過 CoreAnimation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。

CoreAudio

CoreAudio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。

CoreData

提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用或大或小的數據模型。

功能列表：框架分類

下面是 CocoaTouch 中一小部分可用的框架：

• 音頻和視頻

• Core Audio

• OpenAL

• Media Library

• AV Foundation

• 數據管理

• Core Data

• SQLite

• 圖形和動畫

• Core Animation

• OpenGL ES

• Quartz 2D

• 網絡/li>

• Bonjour

• WebKit

• BSD Sockets

• 用戶應用

• Address Book

• Core Location

• Map Kit

• Store Kit

62.objc的內存管理

若是您經過分配和初始化（好比[[MyClass alloc] init]）的方式來建立對象，您就擁 有這個對象，須要負責該對象的釋放。這個規則在使用NSObject的便利方法new 時也一樣適用.

若是您拷貝一個對象，您也擁有拷貝獲得的對象，須要負責該對象的釋放.

若是您保持一個對象，您就部分擁有這個對象，須要在再也不使用時釋放該對象。

若是您從其它對象那裏接收到一個對象，則您不擁有該對象，也不該該釋放它（這個規則有少數 的例外，在參考文檔中有顯式的說明）。

63.自動釋放池是什麼,如何工做

當您向一個對象發送一個autorelease消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。

1. ojc-c 是經過一種"referringcounting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬. 2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的. 3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.

64.類工廠方法是什麼

類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中，返回被建立的對象，並 進行自動釋放處理。這些方法的形式是+ (type)className...（其中 className不包括任何前綴）。

工廠方法可能不只僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠爲初始化過程提供對 象的分配信息。

類工廠方法的另外一個目的是使類（好比NSWorkspace）提供單件實例。雖然init...方法能夠確認一 個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。 工廠方法則能夠避免爲可能沒有用的對象盲目分配內存。

65.單件實例是什麼

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

66.動態綁定—在運行時肯定要調用的方法

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

 特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而透明地發生。

67.obj-c的優缺點

objc優勢：  1)Cateogies   2) Posing   3) 動態識別  4) 指標計算   5）彈性訊息傳遞  6) 不是一個過分複雜的 C 衍生語言  7) Objective-C 與 C++ 可混合編程 

缺點:   1) 不支援命名空間   2) 不支持運算符重載

3）不支持多重繼承

4）使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。

68.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。這是爲了減小對上下文的依賴而引入的機制。 5，nonatomic，非原子性訪問，不加同步，多線程並發訪問會提升性能。注意，若是不加此屬性，則默認是兩個訪問方法都爲原子型事務訪問。鎖被加到所屬對象實例級(我是這麼理解的…)。

~~69.ViewController的 didReceiveMemoryWarning 是在何時被調用的？~~（87題）

70.談談你對ARC 的認識和理解？

71. ObjC中，與alloc語義相反的方法是dealloc仍是release？與retain語義相反的方法是dealloc仍是release，爲何？須要與alloc配對使用的方法是dealloc仍是release，爲何？

alloc與dealloc語意相反，alloc是建立變量，dealloc是釋放變量。 retain 對應release,retain 保留一個對象。調用以後，變量的計數加1。或許不是很明顯，在這有例爲證：

- (void)setName : (NSString*) name {

[name retain];

[myname release];

myname = name; }

咱們來解釋一下：設想，用戶在調用這個函數的時候，他注意了內存的管理，因此他當心的寫了以下代碼：

NSString* newname = [[NSString alloc] initWithString: @"John"];

[aClasssetName: newname];

[newnamerelease];

咱們來看一看newname的計數是怎麼變化的。首先，它被alloc，count = 1; 而後，在setName中，它被retain，count = 2; 最後，用戶本身釋放newname，count= 1，myname指向了newname。這也解釋了爲何須要調用[myname release]。咱們須要在給myname賦新值的時候，釋放掉之前老的變量。retain 以後直接dealloc對象計數器沒有釋放。alloc 須要與release配對使用，由於alloc 這個函數調用以後，變量的計數加1。因此在調用alloc 以後，必定要調用對應的release。另外，在release一個變量以後，他的值仍然有效，因此最好是後面緊接着再var = nil。

72. 在一個對象的方法裏面:

self.name = 「object」;

和

name ＝」object」

有什麼不一樣?

73. 這段代碼有什麼問題:

@implementation Person

- (void)setAge:(int)newAge {

self.age = newAge;

}

@end

74. 什麼是retaincount?

75. 如下每行代碼執行後，person對象的retain count分別是多少

Person *person = [[Person alloc] init];

[person retain];

[person release];

76. 爲何不少內置類如UITableViewController的delegate屬性都是assign而不是retain的？

77. 定義屬性時，什麼狀況使用copy，assign，和retain？

assign用於簡單數據類型，如NSInteger,double,bool,retain和copy用戶對象，copy用於當 a指向一個對象，b也想指向一樣的對象的時候，若是用assign，a若是釋放，再調用b會crash,若是用copy 的方式，a和b各自有本身的內存，就能夠解決這個問題。retain 會使計數器加一，也能夠解決assign的問題。另外：atomic和nonatomic用來決定編譯器生成的getter和setter是否爲原子操做。在多線程環境下，原子操做是必要的，不然有可能引發錯誤的結果。加了atomic，setter函數會變成下面這樣：

if(property != newValue) { [propertyrelease]; property = [newValueretain]; }

78. autorelease的對象是在何時被release的？

答：autorelease實際上只是把對release的調用延遲了，對於每個Autorelease，系統只是把該Object放入了當前的Autoreleasepool中，當該pool被釋放時，該pool中的全部Object會被調用Release。對於每個Runloop，系統會隱式建立一個Autoreleasepool，這樣全部的releasepool會構成一個象CallStack同樣的一個棧式結構，在每個Runloop結束時，當前棧頂的Autoreleasepool會被銷燬，這樣這個pool裏的每一個Object（就是autorelease的對象）會被release。那什麼是一個Runloop呢？一個UI事件，Timer call，delegate call，都會是一個新的Runloop。那什麼是一個Runloop呢？一個UI事件，Timer call，delegate call，都會是一個新的Runloop。

79. 這段代碼有什麼問題,如何修改

for (int i = 0; i < someLargeNumber; i++)

{

NSString *string = @」Abc」;

string = [string lowercaseString];

string = [stringstringByAppendingString:@"xyz"];

NSLog(@「%@」, string);

}

~~80. autorelease和垃圾回收機制(gc)有什麼關係？IPhone OS有沒有垃圾回收（gc）？~~

81. Objective C中的protocal是什麼？

@protocal obj裏面的協議就如同java裏面的interface。

82. Objective C中的selector 是什麼？

你能夠理解 @selector()就是取類方法的編號,他的行爲基本能夠等同C語言的中函數指針,只不過C語言中，能夠把函數名直接賦給一個函數指針，而Objective-C的類不能直接應用函數指針，這樣只能作一個@selector語法來取.它的結果是一個SEL類型。這個類型本質是類方法的編號(函數地址)。

83. Objective C中的category是什麼?

Objective-C提供了一個很是靈活的類(Class)擴展機制－類別(Category)。類別用於對一個已經存在的類添加方法(Methods)。你只須要知道這個類的公開接口，不須要知道類的源代碼。須要注意的是，類別不能爲已存在的類添加實例變量(Instance Variables)。

子類(subclassing)是進行類擴展的另外一種經常使用方法。與子類相比，類別最主要的優勢是：系統中已經存在的類能夠不需修改就可以使用類別的擴展功能。

類別的第二大優勢是實現了功能的局部化封裝。類別定義能夠放在一個已存在的類(類A)的定義文件中(.h)。這意味着這個類別只有在類A被引用的前提下才會被外部看到。若是另外一個類(類B)不須要用到類A的功能(沒有包含類A的.h文件)，也就不會看到依附類A存在的類別。iOS SDK中普遍運用這種類別定義法來封裝功能。

84. 什麼是Notification？何時用delegate，何時用Notification？

觀察者模式，controller向defaultNotificationCenter添加本身的notification，其餘類註冊這個notification就能夠收到通知，這些類能夠在收到通知時作本身的操做（多觀察者默認隨機順序發通知給觀察者們，並且每一個觀察者都要等當前的某個觀察者的操做作完才能輪到他來操做，能夠用NotificationQueue的方式安排觀察者的反應順序，也能夠在添加觀察者中設定反映時間，取消觀察須要在viewDidUnload跟dealloc中都要註銷）。

delegate針對one-to-one關係，而且reciever能夠返回值給sender，notification能夠針對one-to-one/many/none,reciever沒法返回值給sender.因此，delegate用於sender但願接受到reciever的某個功能反饋值，

notification用於通知多個object某個事件。

85. ~~什麼是KVC和KVO？~~Notification和KVO有什麼不一樣？KVO在ObjC中是怎麼實現的？

86. 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 。

87. ViewController 的didReceiveMemoryWarning 是在何時被調用的？UIViewController類中didReceiveMemoryWarning默認的操做是什麼？

答：默認調用[superdidReceiveMemoryWarning]

88. UITableViewController 中，建立UITableViewCell時，initWithSytle:resuseIdentifier中，reuseIdentifier有什麼用？簡述UITableViewCell的複用原理.

複用隊列的元素增長：只有在cell被滑動出界面的時候，此cell纔會被加入到複用隊列中。每次在建立cell的時候，程序會首先經過調用dequeueReusableCellWithIdentifier:cellType方法，到複用隊列中去尋找標示符爲「cellType」的cell，若是找不到，返回nil，而後程序去經過調用[[[UITableViewCell alloc]initWithStyle:style reuseIdentifier:cellType] autorelease]來建立標示符爲「cellType」的cell。

89. UIView 和CALayer 有什麼區別?

二者最大的區別是，圖層不會直接渲染到屏幕上。

90. 以 UIView 類animateWithDuration:animations: 爲例，簡述UIView動畫原理

copy與retain：
一、copy實際上是創建了一個相同的對象，而retain不是；
二、copy是內容拷貝，retain是指針拷貝；
三、copy是內容的拷貝 ,對於像NSString,的確是這樣，可是若是copy的是一個NSArray呢?這時只是copy了指向array中相對應元素的指針.這即是所謂的"淺複製".
四、copy的狀況：NSString *newPt = [pt copy];
此時會在堆上從新開闢一段內存存放@"abc" 好比0X1122 內容爲@"abc 同時會在棧上爲newPt分配空間好比地址：0Xaacc 內容爲0X1122 所以retainCount增長1供newPt來管理0X1122這段內存；
assign與retain：
一、assign: 簡單賦值，不更改索引計數；
二、assign的狀況：NSString *newPt = [pt assing];

此時newPt和pt徹底相同地址都是0Xaaaa 內容爲0X1111 即newPt只是pt的別名，對任何一個操做就等於對另外一個操做，所以retainCount不須要增長；

三、assign就是直接賦值；
四、retain使用了引用計數，retain引發引用計數加1, release引發引用計數減1，當引用計數爲0時，dealloc函數被調用，內存被回收；

五、retain的狀況：NSString *newPt = [pt retain];

此時newPt的地址再也不爲0Xaaaa，可能爲0Xaabb 可是內容依然爲0X1111。所以newPt 和 pt 均可以管理"abc"所在的內存，所以 retainCount須要增長1 ；
readonly：
一、屬性是隻讀的，默認的標記是讀寫，若是你指定了只讀，在@implementation中只須要一個讀取器。或者若是你使用@synthesize關鍵字，也是有讀取器方法被解析
readwrite：
一、說明屬性會被當成讀寫的，這也是默認屬性。設置器和讀取器都須要在@implementation中實現。若是使用@synthesize關鍵字，讀取器和設置器都會被解析；
nonatomic：
一、非原子性訪問，對屬性賦值的時候不加鎖，多線程併發訪問會提升性能。若是不加此屬性，則默認是兩個訪問方法都爲原子型事務訪問；
weak and strong property (強引用和弱引用的區別)：
一、 weak 和 strong 屬性只有在你打開ARC時纔會被要求使用，這時你是不能使用retain release autorelease 操做的，由於ARC會自動爲你作好這些操做，可是你須要在對象屬性上使用weak 和strong,其中strong就至關於retain屬性，而weak至關於assign。
二、只有一種狀況你須要使用weak（默認是strong），就是爲了不retain cycles（就是父類中含有子類{父類retain了子類}，子類中又調用了父類{子類又retain了父類}，這樣都沒法release）
三、聲明爲weak的指針，指針指向的地址一旦被釋放，這些指針都將被賦值爲nil。這樣的好處能有效的防止野指針。

ARC(Automatic Reference Counting):
一、就是代碼中自動加入了retain/release，原先須要手動添加的用來處理內存管理的引用計數的代碼能夠自動地由編譯器完成了。

該機能在 iOS 5/ Mac OS X 10.7 開始導入，利用 Xcode4.2 之後能夠使用該特性。
strong,weak,copy 具體用法：

1.具體一點：IBOutlet能夠爲weak，NSString爲copy，Delegate通常爲weak，其餘的看狀況。通常來講，類「內部」的屬性設置爲strong，類「外部」的屬性設置爲weak。說到底就是一個歸屬權的問題。當心出現循環引用致使內存沒法釋放。
2.不用ARC的話就會看到不少retian。
3.若是你寫了@synthesize abc = _abc；的話，系統自動幫你聲明瞭一個_abc的實例變量。
使用assign: 對基礎數據類型（NSInteger）和C數據類型（int, float, double, char,等）
使用copy：對NSString

使用retain：對其餘NSObject和其子類

1.寫一個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);

}

2static 關鍵字的做用：

（1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次，

所以其值在下次調用時仍維持上次的值；

（2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問；

（3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明

它的模塊內；

（4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝；

（5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。

3線程與進程的區別和聯繫?

進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。

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

4堆和棧的區別

管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。

申請大小：

棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在 WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。所以，能從棧得到的空間較小。

堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。

碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出

分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。

分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。

5什麼是鍵-值,鍵路徑是什麼

鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的

性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型

實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相

關對象的特定屬性。

6目標-動做機制

目標是動做消息的接收者。一個控件，或者更爲常見的是它的單元，以插座變量（參見"插座變量"部分）

的形式保有其動做消息的目標。

動做是控件發送給目標的消息，或者從目標的角度看，它是目標爲了響應動做而實現的方法。

程序須要某些機制來進行事件和指令的翻譯。這個機制就是目標-動做機制。

7objc的內存管理

?? 若是您經過分配和初始化（好比[[MyClass alloc] init]）的方式來建立對象，您就擁

有這個對象，須要負責該對象的釋放。這個規則在使用NSObject的便利方法new 時也一樣適用。

?? 若是您拷貝一個對象，您也擁有拷貝獲得的對象，須要負責該對象的釋放。

?? 若是您保持一個對象，您就部分擁有這個對象，須要在再也不使用時釋放該對象。

反過來，

?? 若是您從其它對象那裏接收到一個對象，則您不擁有該對象，也不該該釋放它（這個規則有少數

的例外，在參考文檔中有顯式的說明）。

8 自動釋放池是什麼,如何工做

2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的.

3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.

9類工廠方法是什麼

類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中，返回被建立的對象，並

進行自動釋放處理。這些方法的形式是+ (type)className...（其中 className不包括任何前綴）。

工廠方法可能不只僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠爲初始化過程提供對

象的分配信息。

類工廠方法的另外一個目的是使類（好比NSWorkspace）提供單件實例。雖然init...方法能夠確認一

個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。

工廠方法則能夠避免爲可能沒有用的對象盲目分配內存。

10單件實例是什麼

Foundation 和 Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager 和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配和初始化。單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比

NSWorkspace），就應該產生一個單件實例，而不是多個實例；若是未來某一天可能有多個實例，您可

以使用單件實例機制，而不是工廠方法或函數。

11動態綁定

—在運行時肯定要調用的方法

特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而透明地發生。

12obj-c的優缺點

objc優勢：

1) Cateogies

2) Posing

3) 動態識別

4) 指標計算

5）彈性訊息傳遞

6) 不是一個過分複雜的 C 衍生語言

7) Objective-C 與 C++ 可混合編程

缺點:

1) 不支援命名空間

2) 不支持運算符重載

3）不支持多重繼承

4）使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。

13sprintf,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格式化的函數的長度不可控，有可能格式化後的字符串會超出緩衝區的大小，形成溢出。

14答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functi***** that take an integer argument and return an integer

15.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函數會變成下面這樣：

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

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

18ViewController 的 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 。

"NSMutableString *"這個數據類型則是表明"NSMutableString"對象自己，這二者是有區別的。

而NSString只是對象的指針而已。

面向過程就是分析出解決問題所須要的步驟，而後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就能夠了。

面向對象是把構成問題事務分解成各個對象，創建對象的目的不是爲了完成一個步驟，而是爲了描敘某個事物在整個解決問題的步驟中的行爲。；

20類別的做用

類別主要有3個做用：

(1)將類的實現分散到多個不一樣文件或多個不一樣框架中。

(2)建立對私有方法的前向引用。

(3)向對象添加非正式協議。

類別的侷限性

有兩方面侷限性：

(1)沒法向類中添加新的實例變量，類別沒有位置容納實例變量。

(2)名稱衝突，即當類別中的方法與原始類方法名稱衝突時，類別具備更高的優先級。類別方法將徹底取代初始方法從而沒法再使用初始方法。

沒法添加實例變量的侷限能夠使用字典對象解決

21關鍵字volatile有什麼含意?並給出三個不一樣的例子：

一個定義爲volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到

這個變量時必須每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子：

• 並行設備的硬件寄存器（如：狀態寄存器）

• 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)

• 多線程應用中被幾個任務共享的變量

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

• 一個指針能夠是volatile 嗎？解釋爲何。

下面是答案：

• 是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。

• 是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。

22@synthesize 是系統自動生成getter和setter屬性聲明

@dynamic 是開發者自已提供相應的屬性聲明

@dynamic 意思是由開發人員提供相應的代碼：對於只讀屬性須要提供 setter，對於讀寫屬性須要提供 setter 和 getter。@synthesize 意思是，除非開發人員已經作了，不然由編譯器生成相應的代碼，以知足屬性聲明。

查閱了一些資料肯定@dynamic的意思是告訴編譯器,屬性的獲取與賦值方法由用戶本身實現, 不自動生成。

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

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

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

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

26What 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就好了，

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

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

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

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

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

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

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

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

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

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

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

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

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

40id、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就是實現方法。

41層和UIView的區別是什麼？

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

42GCD爲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];

});

43Provider是指某個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 .

44.可擴展標記語言extensible markup language;XML

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 a samplestring。這比如是將起始和結束標籤看做是數學中的左右括號：在沒有關閉全部的內部括號以前，是不能關閉外面的括號的。

　　4 全部的特性都必須有值。

　　5 全部的特性都必須在值的周圍加上雙引號。

45union 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的倍數。

46ASIDownloadCache 設置下載緩存

它對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 ];

47HTTP協議詳解

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協議是無狀態協議。無狀態是指協議對於事務處理沒有記憶能力。缺乏狀態意味着若是後續處理須要前面的信息，則它必須重傳，這樣可能致使每次鏈接傳送的數據量增大。另外一方面，在服務器不須要先前信息時它的應答就較快。

48URL

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

49TCP/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協議的差異

是否鏈接面向鏈接面向非鏈接

傳輸可靠性可靠不可靠

應用場合傳輸大量數據少許數據

速度慢快

50socket鏈接和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協議的抽象，從而造成了咱們知道的一些最基本的函數接口。

51什麼是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鏈接的請求，斷開過程須要通過「四次握手」（過程就不細寫了，就是服務器和客戶端交互，最終肯定斷開）

52利用Socket創建網絡鏈接的步驟

創建Socket鏈接至少須要一對套接字，其中一個運行於客戶端，稱爲ClientSocket ，另外一個運行於服務器端，稱爲ServerSocket 。

套接字之間的鏈接過程分爲三個步驟：服務器監聽，客戶端請求，鏈接確認。

1。服務器監聽：服務器端套接字並不定位具體的客戶端套接字，而是處於等待鏈接的狀態，實時監控網絡狀態，等待客戶端的鏈接請求。

2。客戶端請求：指客戶端的套接字提出鏈接請求，要鏈接的目標是服務器端的套接字。爲此，客戶端的套接字必須首先描述它要鏈接的服務器的套接字，指出服務器端套接字的地址和端口號，而後就向服務器端套接字提出鏈接請求。

3。鏈接確認：當服務器端套接字監聽到或者說接收到客戶端套接字的鏈接請求時，就響應客戶端套接字的請求，創建一個新的線程，把服務器端套接字的描述發給客戶端，一旦客戶端確認了此描述，雙方就正式創建鏈接。而服務器端套接字繼續處於監聽狀態，繼續接收其餘客戶端套接字的鏈接請求。

53進程與線程

進程（process）是一塊包含了某些資源的內存區域。操做系統利用進程把它的工做劃分爲一些功能單元。

進程中所包含的一個或多個執行單元稱爲線程（thread）。進程還擁有一個私有的虛擬地址空間，該空間僅能被它所包含的線程訪問。

一般在一個進程中能夠包含若干個線程，它們能夠利用進程所擁有的資源。

在引入線程的操做系統中，一般都是把進程做爲分配資源的基本單位，而把線程做爲獨立運行和獨立調度的基本單位。

因爲線程比進程更小，基本上不擁有系統資源，故對它的調度所付出的開銷就會小得多，能更高效的提升系統內多個程序間併發執行的程度。

線程只能歸屬於一個進程而且它只能訪問該進程所擁有的資源。當操做系統建立一個進程後，該進程會自動申請一個名爲主線程或首要線程的線程。應用程序（application）是由一個或多個相互協做的進程組成的。

另外，進程在執行過程當中擁有獨立的內存單元，而多個線程共享內存，從而極大地提升了程序的運行效率。
線程在執行過程當中與進程仍是有區別的。每一個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。可是線程不可以獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。
從邏輯角度來看，多線程的意義在於一個應用程序中，有多個執行部分能夠同時執行。但操做系統並無將多個線程看作多個獨立的應用，來實現進程的調度和管理以及資源分配。這就是進程和線程的重要區別。

進程是具備必定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位.
線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程本身基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),可是它可與同屬一個進程的其餘的線程共享進程所擁有的所有資源.
一個線程能夠建立和撤銷另外一個線程;同一個進程中的多個線程之間能夠併發執行.

多線程編程是防止主線程堵塞，增長運行效率等等的最佳方法。而原始的多線程方法存在不少的毛病，包括線程鎖死等。在Cocoa中，Apple提供了NSOperation這個類，提供了一個優秀的多線程編程方法。

本次介紹NSOperation的子集，簡易方法的NSInvocationOperation：

一個NSOperationQueue 操做隊列，就至關於一個線程管理器，而非一個線程。由於你能夠設置這個線程管理器內能夠並行運行的的線程數量等等

55oc語法裏的@perpoerty不用寫@synzhesize了，自動填充了。而且的_name;

寫方法時候不用提早聲明。llvm 全局方法便利。

枚舉類型。enum hello:Integer{ } 冒號後面直接能夠跟類型，之前是：

enum hello{} 後面在指定爲Integer .

橋接。ARC 自動release retain 的時候 CFString CFArray . Core Fountion. 加上橋接_brige 才能區分CFString 和NSString 而如今自動區分了，叫固定橋接。

下拉刷新封裝好了。

UICollectionViewController. 能夠把表格分紅多列。

Social Framework(社交集成)

UIActivityViewController來詢問用戶的社交行爲

緩存：就是存放在臨時文件裏，好比新浪微博請求的數據，和圖片，下次請求看這裏有沒有值。

56Singleton（單例模式），也叫單子模式，是一種經常使用的軟件設計模式。在應用這個模式時，單例對象的類必須保證只有一個實例存在。

代碼以下：

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;

}

- (NSUIntger)retainCount {

return NSUIntgerMax;

}

- (oneway void)release {

}

- (id)autorelease {

return self;

}

-(void)dealloc{

}

57請寫一個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的話就是小端了吧。

堆和棧上的指針

指針所指向的這塊內存是在哪裏分配的,在堆上稱爲堆上的指針,在棧上爲棧上的指針.

在堆上的指針,能夠保存在全局數據結構中,供不一樣函數使用訪問同一塊內存.

在棧上的指針,在函數退出後,該內存即不可訪問.

59什麼是指針的釋放?

具體來講包括兩個概念.

1 釋放該指針指向的內存,只有堆上的內存才須要咱們手工釋放,棧上不須要.

2 將該指針重定向爲NULL.

60數據結構中的指針?

其實就是指向一塊內存的地址,經過指針傳遞,可實現複雜的內存訪問.

7 函數指針?

指向一塊函數的入口地址.

8 指針做爲函數的參數?

好比指向一個複雜數據結構的指針做爲函數變量

這種方法避免整個複雜數據類型內存的壓棧出棧操做,提升效率.

注意:指針自己不可變,但指針指向的數據結構能夠改變.

9 指向指針的指針?

指針指向的變量是一個指針,即具體內容爲一個指針的值,是一個地址.

此時指針指向的變量長度也是4位.

61指針與地址的區別?

區別:

1指針意味着已經有一個指針變量存在,他的值是一個地址,指針變量自己也存放在一個長度爲四個字節的地址當中,而地址概念自己並不表明有任何變量存在.

2 指針的值,若是沒有限制,一般是能夠變化的,也能夠指向另一個地址.

地址表示內存空間的一個位置點,他是用來賦給指針的,地址自己是沒有大小概念,指針指向變量的大小,取決於地址後面存放的變量類型.

62指針與數組名的關係?

其值都是一個地址,但前者是能夠移動的,後者是不可變的.

12 怎樣防止指針的越界使用問題?

必須讓指針指向一個有效的內存地址,

1 防止數組越界

2 防止向一塊內存中拷貝過多的內容

3 防止使用空指針

4 防止改變const修改的指針

5 防止改變指向靜態存儲區的內容

6 防止兩次釋放一個指針

7 防止使用野指針.

13 指針的類型轉換?

指針轉換一般是指針類型和void * 類型以前進行強制轉換,從而與指望或返回void指針的函數進行正確的交接.

63static有什麼用途？（請至少說明兩種）
            1.限制變量的做用域
            2.設置變量的存儲域
            7. 引用與指針有什麼區別？
            1) 引用必須被初始化，指針沒必要。
            2) 引用初始化之後不能被改變，指針能夠改變所指的對象。
            2) 不存在指向空值的引用，可是存在指向空值的指針。
            8. 描述實時系統的基本特性
            在特定時間內完成特定的任務，實時性與可靠性

64全局變量和局部變量在內存中是否有區別？若是有，是什麼區別？
            全局變量儲存在靜態數據庫，局部變量在堆棧
            10. 什麼是平衡二叉樹？
            左右子樹都是平衡二叉樹且左右子樹的深度差值的絕對值不大於1

            局部變量能夠與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而
            不會用到全局變量。對於有些編譯器而言，在同一個函數內能夠定義多個同名的局部變
            量，好比在兩個循環體內都定義一個同名的局部變量，而那個局部變量的做用域就在那
            個循環體內
            二、如何引用一個已經定義過的全局變量？
            答：extern
            能夠用引用頭文件的方式，也能夠用extern關鍵字，若是用引用頭文件方式來引用某個
            在頭文件中聲明的全局變理，假定你將那個變寫錯了，那麼在編譯期間會報錯，若是你
            用extern方式引用時，假定你犯了一樣的錯誤，那麼在編譯期間不會報錯，而在鏈接期
            間報錯
            三、全局變量可不能夠定義在可被多個.C文件包含的頭文件中？爲何？
            答：能夠，在不一樣的C文件中以static形式來聲明同名全局變量。
            能夠在不一樣的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦
            初值，此時鏈接不會出錯
            四、語句for( ；1 ；)有什麼問題？它是什麼意思？
            答：和while(1)相同。
            五、do……while和while……do有什麼區別？
            答：前一個循環一遍再判斷，後一個判斷之後再循環

661.IP Phone的原理是什麼?
            IPV6
            2.TCP/IP通訊創建的過程怎樣，端口有什麼做用？
            三次握手，肯定是哪一個應用程序使用該協議
            3.1號信令和7號信令有什麼區別，我國某前普遍使用的是那一種？
            4.列舉5種以上的電話新業務？
            微軟亞洲技術中心的面試題！！！
            1．進程和線程的差異。
            線程是指進程內的一個執行單元,也是進程內的可調度實體.
            與進程的區別:
            (1)調度：線程做爲調度和分配的基本單位，進程做爲擁有資源的基本單位
            (2)併發性：不只進程之間能夠併發執行，同一個進程的多個線程之間也可併發執行
            (3)擁有資源：進程是擁有資源的一個獨立單位，線程不擁有系統資源，但能夠訪問隸屬
            於進程的資源.
            (4)系統開銷：在建立或撤消進程時，因爲系統都要爲之分配和回收資源，致使系統的開
            銷明顯大於建立或撤消線程時的開銷。
            2.測試方法
            人工測試：我的複查、抽查和會審
            機器測試：黑盒測試和白盒測試
            2．Heap與stack的差異。
            Heap是堆，stack是棧。
            Stack的空間由操做系統自動分配/釋放，Heap上的空間手動分配/釋放。
            Stack空間有限，Heap是很大的自由存儲區
            C中的malloc函數分配的內存空間即在堆上,C++中對應的是new操做符。
            程序在編譯期對變量和函數分配內存都在棧上進行,且程序運行過程當中函數調用時參數的
            傳遞也在棧上進行
            3．Windows下的內存是如何管理的？
            4．介紹.Net和.Net的安全性。
            5．客戶端如何訪問.Net組件實現Web Service？
            6．C/C++編譯器中虛表是如何完成的？
            7．談談COM的線程模型。而後討論進程內/外組件的差異。
            8．談談IA32下的分頁機制
            小頁(4K)兩級分頁模式，大頁(4M)一級
            9．給兩個變量，如何找出一個帶環單鏈表中是什麼地方出現環的？
            一個遞增一，一個遞增二，他們指向同一個接點時就是環出現的地方
            10．在IA32中一共有多少種辦法從用戶態跳到內核態？
            經過調用門，從ring3到ring0，中斷從ring3到ring0，進入vm86等等
            11．若是隻想讓程序有一個實例運行，不能運行兩個。像winamp同樣，只能開一個窗
            口，怎樣實現？
            用內存映射或全局原子（互斥變量）、查找窗口句柄..
            FindWindow，互斥，寫標誌到文件或註冊表,共享內存。

67如何截取鍵盤的響應，讓全部的‘a’變成‘b’？
            鍵盤鉤子SetWindowsHookEx
            13．Apartment在COM中有什麼用？爲何要引入？
            14．存儲過程是什麼？有什麼用？有什麼優勢？
            個人理解就是一堆sql的集合，能夠創建很是複雜的查詢，編譯運行，因此運行一次後，
            之後再運行速度比單獨執行SQL快不少
            15．Template有什麼特色？何時用？
            16．談談Windows DNA結構的特色和優勢。
            網絡編程中設計併發服務器，使用多進程與多線程，請問有什麼區別？
            1，進程：子進程是父進程的複製品。子進程得到父進程數據空間、堆和棧的複製品。
            2，線程：相對與進程而言，線程是一個更加接近與執行體的概念，它能夠與同進程的其
            他線程共享數據，但擁有本身的棧空間，擁有獨立的執行序列。
            二者均可以提升程序的併發度，提升程序運行效率和響應時間。
            線程和進程在使用上各有優缺點：線程執行開銷小，但不利於資源管理和保護；而進程
            正相反。同時，線程適合於在SMP機器上運行，而進程則能夠跨機器遷移。
            思科

682.找錯題

　　試題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

nGET和POST是兩種最經常使用的與服務器進行交互的HTTP方法

nGET

nGET的語義是獲取指定URL的資源

n將數據按照variable=value的形式，添加到action所指向的URL後面，而且二者使用"?"鏈接，各變量之間使用"&"鏈接

n貌似不安全，由於在傳輸過程當中，數據被放在請求的URL中

n傳輸的數據量小，這主要是由於受URL長度限制

nPOST

nPOST的語義是向指定URL的資源添加數據

n將數據放在數據體中，按照變量和值相對應的方式，傳遞到action所指向URL

n全部數據對用戶來講不可見

n能夠傳輸大量數據，上傳文件只能使用Pos

大多數求職者只會答出get時安全的，post時不安全的，但這個答案是錯誤的！！

真正的區別在於：

get請求時一個取的過程，沒有數據體的存在，

對於用戶而言，get是不安全的，發送的參數都裸露在外邊

對於服務器而言，它時安全的，由於它沒有給服務器發送真正的數據體

post請求時一個先發再取的過程，右數據體的存在

對於用戶而言，post時相對安全的，由於發送的參數都在數據體中隱藏着

對於服務器而言，它是不安全的，由於它能夠給服務器發送真正的數據體，若是有人想攻擊這臺服務器，徹底能夠控制大量的計算機給這臺服務器發送post請求，就會形成拒絕服務攻擊

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;
}

- (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]);
=======================================================

=======================================================
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: afterDelay: 或者使用GCD的函數：dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒後異步執行這裏的代碼...
});

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

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

淺複製和深複製的區別？
答案：淺層複製：只複製指向對象的指針，而不復制引用對象自己。
深層複製：複製引用對象自己。
意思就是說我有個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就好了，
能夠按照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. 你使用過Objective-C的運行時編程（Runtime Programming）麼？若是使用過，你用它作了什麼？你還能記得你所使用的相關的頭文件或者某些方法的名稱嗎？

Objecitve-C的重要特性是Runtime（運行時）,在#import <objc/runtime.h> 下能看到相關的方法，

同運行時交互主要在三個不一樣的地方，分別是

A.Objective-C 源碼（譬如：你定義的Category中的新方法會在運行時自動添加到原始類）

B.NSObject 的方法（isMemberClassOf 等動態判定的方法）

C.運行時函數。

Objective-C跟C最大的差異，應當是動態定型（dynamicaly typed），支撐在運行時

動態類型決定（dynamic typing），動態綁定（dynamic binding）以及動態裝載（dynamic loading）。

Objective-C 在運行時能夠允許按照字符串名字來接見辦法和類，還能夠動態鏈接和添加類，

而C說話編譯時靜態綁定，甚至不少時辰你沒定義的辦法直接就編譯不過。

用過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時使用到。

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

Core Data是iOS5以後纔出現的一個框架，它提供了對象-關係映射(ORM)的功能，即可以將OC對象轉化成數據，保存在SQLite數據庫文件中，也可以將保存在數據庫中的數據還原成OC對象。在此數據操做期間，咱們不須要編寫任何SQL語句，這個有點相似於著名的Hibernate持久化框架，不過功能確定是沒有Hibernate強大的。簡單地用下圖描述下它的做用：

利用Core Data框架，咱們就能夠輕鬆地將數據庫裏面的2條記錄轉換成2個OC對象，也能夠輕鬆地將2個OC對象保存到數據庫中，變成2條表記錄，並且不用寫一條SQL語句, 另外支持自動撤銷機制，一對多關聯等

Core data 是 Cocoa 中處理數據，綁定數據的關鍵特性，其重要性不言而喻，但也比較複雜。Core Data 相關的類比較多，初學者每每不太容易弄懂。計劃用三個教程來說解這一部分：

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

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

4. NSNotification和KVO的區別和用法是什麼？何時應該使用通知，何時應該使用KVO，它們的實現上有什麼區別嗎？若是用protocol和delegate（或者delegate的Array）來實現相似的功能可能嗎？若是可能，會有什麼潛在的問題？若是不能，爲何？（雖然protocol和delegate這種東西面試已經面爛了…）

NSNotification是通知模式在iOS的實現，

KVC（key-value coding）是一個經過屬性名訪問屬性變量的機制。

KVO的全稱是鍵值觀察(Key-value observing),其是基於KVC的，

例如將Module層的變化，通知到多個Controller對象時，能夠使用NSNotification；若是是隻須要觀察某個對象的某個屬性，能夠使用KVO。
對於委託模式，在設計模式中是對象適配器模式，其是delegate是指向某個對象的，這是一對一的關係，

而在通知模式中，每每是一對多的關係。

委託模式，從技術上能夠實現改變delegate指向的對象，但不建議這樣作，會讓人迷惑，若是一個delegate對象不斷改變，指向不一樣的對象。

6.你用過NSOperationQueue麼？若是用過或者瞭解的話，你爲何要使用NSOperationQueue，實現了什麼？請描述它和GCD的區別和相似的地方（提示：能夠從二者的實現機制和適用範圍來描述）。
使用NSOperationQueue用來管理子類化的NSOperation對象，控制其線程併發數目。

GCD和NSOperation都能夠實現對線程的管理，區別是 NSOperation和NSOperationQueue是多線程的面向對象抽象。

項目中使用NSOperation的優勢是NSOperation是對線程的高度抽象，在項目中使用它，會使項目的程序結構更好，子類化NSOperation的設計思路，是具備面向對象的優勢（複用、封裝），使得實現是多線程支持，而接口簡單，建議在複雜項目中使用。
項目中使用GCD的優勢是GCD自己很是簡單、易用，對於不復雜的多線程操做，會節省代碼量，而Block參數的使用，會是代碼更爲易讀，建議在簡單項目中使用。

7.既然提到GCD，那麼問一下在使用GCD以及block時要注意些什麼？它們兩是一回事兒麼？block在ARC中和傳統的MRC中的行爲和用法有沒有什麼區別，須要注意些什麼？
使用block是要注意，

若將block作函數參數時，須要把它放到最後，

GCD是Grand Central Dispatch，

是一個對線程開源類庫，而Block是閉包，是可以讀取其餘函數內部變量的函數。

block自身的內存管理**

block自己是像對象同樣能夠retain，和release。可是，block在建立的時候，它的內存是分配在棧(stack)上，而不是在堆(heap)上。他自己的做於域是屬於建立時候的做用域，一旦在建立時候的做用域外面調用block將致使程序崩潰，

在其餘地方使用的解決方法是，建完block的時候須要調用copy的方法。copy會把block從棧上移動到堆上，那麼就能夠在其餘地方使用這個block了~

block中能夠直接使用外部的變量

block循環引用

當在block內部使用成員變量的時候調用 self.str (str是self成員變量)， block內部調用 self.str 時，str會retain一次，此時當self釋放的時候，須要block釋放後纔會對self進行釋放，可是block的釋放又須要等self的dealloc中才會釋放。如此一來變造成了循環引用，致使內存泄露。

修改方案：是新建一個__block scopeVC的局部變量，並把self賦值給它，而在block內部則使用這個局部變量來進行取值。由於__block標記的變量是不會被自動retain的

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

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

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

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。