iOS面試小貼士html
———————————————回答好下面的足夠了-------------------------------------前端
多線程、特別是NSOperation 和 GCD 的內部原理。java
運行時機制的原理和運用場景。ios
SDWebImage的原理。實現機制。如何解決TableView卡的問題。c++
block和代理的，通知的區別。block的用法須要注意些什麼。git
strong，weak，retain，assign，copy nomatic 等的區別。程序員
設計模式，mvc，單利，工廠，代理等的應用場景。web
單利的寫法。在單利中建立數組應該注意些什麼。面試
NSString 的時候用copy和strong的區別。算法
響應值鏈。
NSTimer 在子線程中應該手動建立NSRunLoop ，不然不能循環執行。
UIScrollView和NSTimer組合作循環廣告圖輪播的時候有一個屬性能夠控制當上下滾動tableview的時候廣告輪播圖依然正常滾動。
Xcode最新的自動佈局。。。這個不少公司都用。儘可能自學下。
git ，和svn的用法。。。git的幾個命令簡單的記下。。。
友盟報錯能夠查到具體某一行的錯誤，原理是什麼。
Instrument 能夠檢測 電池的耗電量、和內存的消耗。的用法。
動畫CABaseAnimation CAKeyAni…. CATrans….. CAGoup…. 等熟悉。。
ARC的原理。
本身寫過什麼自定義控件就最好了。。
———————————————回答好上面的足夠了-------------------------------------
__block和__weak修飾符的區別實際上是挺明顯的：
1.__block無論是ARC仍是MRC模式下均可以使用，能夠修飾對象，還能夠修飾基本數據類型。
2.__weak只能在ARC模式下使用，也只能修飾對象（NSString），不能修飾基本數據類型（int）。
3.__block對象能夠在block中被從新賦值，__weak不能夠。
tableView 滑動卡的問題主要是由於：從緩存中或者是從本地讀取圖片給UIImage的時候耗費的時間。須要把下面的兩句話放到子線程裏面：
- NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:app.icon]]; //獲得圖像數據
- UIImage *image = [UIImage imageWithData:imgData];
把UIImage賦值給圖片的時候在主線程。
子線程不能更新UI 全部的UI跟新都是主線程執行了。手指滑動屏幕了。或者屏幕的某個方法執行了。
子線程裏面加入NSTimer 的時候須要 手動添加NSRunloop 不然不能循環。
單利裏面添加 NSMutableArray 的時候，防止多個地方對它同時便利和修改的話，須要加原子屬性。而且用strong，，，而且寫一個遍歷和修改的方法。加上鎖。 Lock UnLock
__weak ViewController* weakSelf = self;
GCD裏面用 __weak 防止內存釋放不了，循環引用。
2、SDWebImage內部實現過程
-
入口 setImageWithURL:placeholderImage:options: 會先把 placeholderImage 顯示，而後 SDWebImageManager 根據 URL 開始處理圖片。
-
進入 SDWebImageManager-downloadWithURL:delegate:options:userInfo:，交給 SDImageCache 從緩存查找圖片是否已經下載 queryDiskCacheForKey:delegate:userInfo:.
-
先從內存圖片緩存查找是否有圖片，若是內存中已經有圖片緩存，SDImageCacheDelegate 回調 imageCache:didFindImage:forKey:userInfo: 到 SDWebImageManager。
-
SDWebImageManagerDelegate 回調 webImageManager:didFinishWithImage: 到 UIImageView+WebCache 等前端展現圖片。
-
若是內存緩存中沒有，生成 NSInvocationOperation 添加到隊列開始從硬盤查找圖片是否已經緩存。
-
根據 URLKey 在硬盤緩存目錄下嘗試讀取圖片文件。這一步是在 NSOperation 進行的操做，因此回主線程進行結果回調 notifyDelegate:。
-
若是上一操做從硬盤讀取到了圖片，將圖片添加到內存緩存中（若是空閒內存太小，會先清空內存緩存）。SDImageCacheDelegate 回調 imageCache:didFindImage:forKey:userInfo:。進而回調展現圖片。
-
若是從硬盤緩存目錄讀取不到圖片，說明全部緩存都不存在該圖片，須要下載圖片，回調 imageCache:didNotFindImageForKey:userInfo:。
-
共享或從新生成一個下載器 SDWebImageDownloader 開始下載圖片。
-
圖片下載由 NSURLConnection 來作，實現相關 delegate 來判斷圖片下載中、下載完成和下載失敗。
-
connection:didReceiveData: 中利用 ImageIO 作了按圖片下載進度加載效果。
-
connectionDidFinishLoading: 數據下載完成後交給 SDWebImageDecoder 作圖片解碼處理。
-
圖片解碼處理在一個 NSOperationQueue 完成，不會拖慢主線程 UI。若是有須要對下載的圖片進行二次處理，最好也在這裏完成，效率會好不少。
-
在主線程 notifyDelegateOnMainThreadWithInfo: 宣告解碼完成，imageDecoder:didFinishDecodingImage:userInfo: 回調給 SDWebImageDownloader。
-
imageDownloader:didFinishWithImage: 回調給 SDWebImageManager 告知圖片下載完成。
-
通知全部的 downloadDelegates 下載完成，回調給須要的地方展現圖片。
-
將圖片保存到 SDImageCache 中，內存緩存和硬盤緩存同時保存。寫文件到硬盤也在以單獨 NSInvocationOperation 完成，避免拖慢主線程。
-
SDImageCache 在初始化的時候會註冊一些消息通知，在內存警告或退到後臺的時候清理內存圖片緩存，應用結束的時候清理過時圖片。
-
SDWI 也提供了 UIButton+WebCache 和 MKAnnotationView+WebCache，方便使用。
-
SDWebImagePrefetcher 能夠預先下載圖片，方便後續使用。
從上面流程能夠看出，當你調用setImageWithURL:方法的時候，他會自動去給你幹這麼多事，當你須要在某一具體時刻作事情的時候，你能夠覆蓋這些方法。好比在下載某個圖片的過程當中要響應一個事件，就覆蓋這個方法：
|
1
2
3
4
5
6
7
8
9
10
11
|
//覆蓋方法，指哪打哪，這個方法是下載imagePath2的時候響應
SDWebImageManager *manager = [SDWebImageManager sharedManager];
[manager downloadImageWithURL:imagePath2 options:SDWebImageRetryFailed progress:^(NSInteger receivedSize, NSInteger expectedSize) {
NSLog(@
"顯示當前進度"
);
} completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
NSLog(@
"下載完成"
);
}];
|
對於初級來講，用sd_setImageWithURL:的若干個方法就能夠實現很好的圖片緩存。
UIButton 的父類是UIControl UIControl的父類是UIView UIView的父類是 UIResponder
http狀態嗎 ：302 是請求重定向。500以上是服務器錯誤。400以上是請求連接錯誤或者找不到服務器。200以上是正確。100以上是請求接受成功。
Keep-Alive: timeout=5, max=100
timeout：過時時間5秒（對應httpd.conf裏的參數是：KeepAliveTimeout），max是最多一百次請求，強制斷掉鏈接
就是在timeout時間內又有新的鏈接過來，同時max會自動減1，直到爲0，強制斷掉。見下面的四個圖，注意看Date的值（先後時間差都是在5秒以內）！
Not reliable（不可靠）
HTTP是一個無狀態協議，這意味着每一個請求都是獨立的，Keep-Alive沒能改變這個結果。另外，Keep-Alive也不能保證客戶端和服務器之間的鏈接必定是活躍的，在HTTP1.1版本中也如此。惟一能保證的就是當鏈接被關閉時你能獲得一個通知，因此不該該讓程序依賴於Keep-Alive的保持鏈接特性，不然會有意想不到的後果
Keep-Alive和POST
在HTTP1.1細則中規定了在一個POST消息體後面不能有任何字符，還指出了對於某一個特定的瀏覽器可能並不遵循這個標準（好比在POST消息體的後面放置一個CRLF符）。而據我所知，大部分瀏覽器在POST消息體後都會自動跟一個CRLF符再發送，如何解決這個問題呢？根據上面的說明在POST請求頭中禁止使用Keep-Alive，或者由服務器自動忽略這個CRLF，大部分服務器都會自動忽略，可是在未經測試以前是不可能知道一個服務器是否會這樣作。
一、經常使用的方法dispatch_async
爲了不界面在處理耗時的操做時卡死，好比讀取網絡數據，IO,數據庫讀寫等，咱們會在另一個線程中處理這些操做，而後通知主線程更新界面。
用GCD實現這個流程的操做比前面介紹的NSThread NSOperation的方法都要簡單。代碼框架結構以下：
- dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
- // 耗時的操做
- dispatch_async(dispatch_get_main_queue(), ^{
- // 更新界面
- });
- });
- dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
- NSURL * url = [NSURL URLWithString:@"http://avatar.csdn.net/2/C/D/1_totogo2010.jpg"];
- NSData * data = [[NSData alloc]initWithContentsOfURL:url];
- UIImage *image = [[UIImage alloc]initWithData:data];
- if (data != nil) {
- dispatch_async(dispatch_get_main_queue(), ^{
- self.imageView.image = image;
- });
- }
- });
運行顯示：
系統給每個應用程序提供了三個concurrent dispatch queues。這三個併發調度隊列是全局的，它們只有優先級的不一樣。由於是全局的，咱們不須要去建立。咱們只須要經過使用函數dispath_get_global_queue去獲得隊列，以下：
- dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
這裏也用到了系統默認就有一個串行隊列main_queue
- dispatch_queue_t mainQ = dispatch_get_main_queue();
雖然dispatch queue是引用計數的對象，可是以上兩個都是全局的隊列，不用retain或release。
二、dispatch_group_async的使用
dispatch_group_async能夠實現監聽一組任務是否完成，完成後獲得通知執行其餘的操做。這個方法頗有用，好比你執行三個下載任務，當三個任務都下載完成後你才通知界面說完成的了。下面是一段例子代碼：
- dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
- dispatch_group_t group = dispatch_group_create();
- dispatch_group_async(group, queue, ^{
- [NSThread sleepForTimeInterval:1];
- NSLog(@"group1");
- });
- dispatch_group_async(group, queue, ^{
- [NSThread sleepForTimeInterval:2];
- NSLog(@"group2");
- });
- dispatch_group_async(group, queue, ^{
- [NSThread sleepForTimeInterval:3];
- NSLog(@"group3");
- });
- dispatch_group_notify(group, dispatch_get_main_queue(), ^{
- NSLog(@"updateUi");
- });
- dispatch_release(group);
2012-09-25 16:04:16.737 gcdTest[43328:11303] group1
2012-09-25 16:04:17.738 gcdTest[43328:12a1b] group2
2012-09-25 16:04:18.738 gcdTest[43328:13003] group3
2012-09-25 16:04:18.739 gcdTest[43328:f803] updateUi
每一個一秒打印一個，當第三個任務執行後，upadteUi被打印。
三、dispatch_barrier_async的使用
dispatch_barrier_async是在前面的任務執行結束後它才執行，並且它後面的任務等它執行完成以後纔會執行
例子代碼以下：
- dispatch_queue_t queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_CONCURRENT);
- dispatch_async(queue, ^{
- [NSThread sleepForTimeInterval:2];
- NSLog(@"dispatch_async1");
- });
- dispatch_async(queue, ^{
- [NSThread sleepForTimeInterval:4];
- NSLog(@"dispatch_async2");
- });
- dispatch_barrier_async(queue, ^{
- NSLog(@"dispatch_barrier_async");
- [NSThread sleepForTimeInterval:4];
- });
- dispatch_async(queue, ^{
- [NSThread sleepForTimeInterval:1];
- NSLog(@"dispatch_async3");
- });
打印結果：
2012-09-25 16:20:33.967 gcdTest[45547:11203] dispatch_async1
2012-09-25 16:20:35.967 gcdTest[45547:11303] dispatch_async2
2012-09-25 16:20:35.967 gcdTest[45547:11303] dispatch_barrier_async
2012-09-25 16:20:40.970 gcdTest[45547:11303] dispatch_async3
請注意執行的時間，能夠看到執行的順序如上所述。四、dispatch_apply
執行某個代碼片斷N次。
dispatch_apply(5, globalQ, ^(size_t index) {
// 執行5次
});
一、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];
四、retain使用了引用計數，retain引發引用計數加1, release引發引用計數減1，當引用計數爲0時，dealloc函數被調用，內存被回收；
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。這樣的好處能有效的防止野指針。
一、就是代碼中自動加入了retain/release，原先須要手動添加的用來處理內存管理的引用計數的代碼能夠自動地由編譯器完成了。
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 自動釋放池是什麼,如何工做
當您向一個對象發送一個autorelease消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。
1. ojc-c 是經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬.
2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的.
3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.
9類工廠方法是什麼
類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中，返回被建立的對象，並
進行自動釋放處理。這些方法的形式是+ (type)className...（其中 className不包括任何前綴）。
工廠方法可能不只僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠爲初始化過程提供對
象的分配信息。
類工廠方法的另外一個目的是使類（好比NSWorkspace）提供單件實例。雖然init...方法能夠確認一
個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。
工廠方法則能夠避免爲可能沒有用的對象盲目分配內存。
10單件實例是什麼
Foundation 和 Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager 和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配和初始化。單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比
NSWorkspace），就應該產生一個單件實例，而不是多個實例；若是未來某一天可能有多個實例，您可
以使用單件實例機制，而不是工廠方法或函數。
11動態綁定
—在運行時肯定要調用的方法
動態綁定將調用方法的肯定也推遲到運行時。在編譯時，方法的調用並不和代碼綁定在一塊兒，只有在消實發送出來以後，才肯定被調用的代碼。經過動態類型和動態綁定技術，您的代碼每次執行均可以獲得不一樣的結果。運行時因子負責肯定消息的接收者和被調用的方法。運行時的消息分發機制爲動態綁定提供支持。當您向一個動態類型肯定了的對象發送消息時，運行環境系統會經過接收者的isa指針定位對象的類，並以此爲起點肯定被調用的方法，方法和消息是動態綁定的。並且，您沒必要在Objective-C 代碼中作任何工做，就能夠自動獲取動態綁定的好處。您在每次發送消息時，
特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而透明地發生。
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 。
19
"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？
關於多態性
答案：多態，子類指針能夠賦值給父類。
這個題目其實能夠出到一切面向對象語言中，
所以關於多態，繼承和封裝基本最好都有個自我意識的理解，也並不是必定要把書上資料上寫的能背出來。
最重要的是轉化成自我理解。
33
What is responder chain?
說說響應鏈
答案：事件響應鏈。包括點擊事件，畫面刷新事件等。在視圖棧內從上至下，或者從下之上傳播。
能夠說點事件的分發，傳遞以及處理。具體能夠去看下touch事件這塊。由於問的太抽象化了
嚴重懷疑題目出到越後面就越籠統。
34Difference between frame and bounds?
frame和bounds有什麼不一樣？
答案:frame指的是：該view在父view座標系統中的位置和大小。（參照點是父親的座標系統）
bounds指的是：該view在自己座標系統中 的位置和大小。（參照點是自己座標系統）
35
.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調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程本身基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),可是它可與同屬一個進程的其餘的線程共享進程所擁有的所有資源.
一個線程能夠建立和撤銷另外一個線程;同一個進程中的多個線程之間能夠併發執行.
54多線程
多線程編程是防止主線程堵塞，增長運行效率等等的最佳方法。而原始的多線程方法存在不少的毛病，包括線程鎖死等。在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的話就是小端了吧。
58
堆和棧上的指針
指針所指向的這塊內存是在哪裏分配的,在堆上稱爲堆上的指針,在棧上爲棧上的指針.
在堆上的指針,能夠保存在全局數據結構中,供不一樣函數使用訪問同一塊內存.
在棧上的指針,在函數退出後,該內存即不可訪問.
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
65堆棧溢出通常是由什麼緣由致使的？
沒有回收垃圾資源
12. 什麼函數不能聲明爲虛函數？
constructor
13. 冒泡排序算法的時間複雜度是什麼？
O(n^2)
14. 寫出float x 與「零值」比較的if語句。
if(x>0.000001&&x<-0.000001)
16. Internet採用哪一種網絡協議？該協議的主要層次結構？
tcp/ip 應用層/傳輸層/網絡層/數據鏈路層/物理層
17. Internet物理地址和IP地址轉換採用什麼協議？
ARP (Address Resolution Protocol)（地址解析協議）
18.IP地址的編碼分爲哪倆部分？
IP地址由兩部分組成，網絡號和主機號。不過是要和「子網掩碼」按位與上以後才能區
分哪些是網絡位哪些是主機位。
2.用戶輸入M,N值，從1至N開始順序循環數數，每數到M輸出該數值，直至所有輸出。寫
出C程序。
循環鏈表，用取餘操做作
3.不能作switch()的參數類型是：
switch的參數不能爲實型。
華為
一、局部變量可否和全局變量重名？
答：能，局部會屏蔽全局。要用全局變量，須要使用"::"
局部變量能夠與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而
不會用到全局變量。對於有些編譯器而言，在同一個函數內能夠定義多個同名的局部變
量，好比在兩個循環體內都定義一個同名的局部變量，而那個局部變量的做用域就在那
個循環體內
二、如何引用一個已經定義過的全局變量？
答：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