Ios教程網 >> IOS編程開發 >> IOS開發綜合 >> Ios中常見的問題

Ios中常見的問題

編輯：IOS開發綜合

__block和__weak修飾符的區別其實是挺明顯的：

1.__block不管是ARC還是MRC模式下都可以使用，可以修飾對象，還可以修飾基本數據類型。

2.__weak只能在ARC模式下使用，也只能修飾對象(NSString)，不能修飾基本數據類型(int)。

3.__block對象可以在block中被重新賦值，__weak不可以。

tableView 滑動卡的問題主要是因為：從緩存中或者是從本地讀取圖片給UIImage的時候耗費的時間。需要把下面的兩句話放到子線程裡面：

NSData*imgData=[NSDatadataWithContentsOfURL:[NSURLURLWithString:app.icon]];//得到圖像數據

UIImage*image=[UIImageimageWithData:imgData];

把UIImage賦值給圖片的時候在主線程。

子線程不能更新UI 所有的UI跟新都是主線程執行了。手指滑動屏幕了。或者屏幕的某個方法執行了。

子線程裡面加入NSTimer 的時候需要手動添加NSRunloop 否則不能循環。

單利裡面添加 NSMutableArray 的時候，防止多個地方對它同時便利和修改的話，需要加原子屬性。並且用strong，，，並且寫一個遍歷和修改的方法。加上鎖。 Lock UnLock

__weak ViewController* weakSelf = self;

GCD裡面用 __weak 防止內存釋放不了，循環引用。

二、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=[SDWebImageManagersharedManager];[managerdownloadImageWithURL:imagePath2options:SDWebImageRetryFailedprogress:^(NSIntegerreceivedSize,NSIntegerexpectedSize){ NSLog(@"顯示當前進度"); }completed:^(UIImage*image,NSError*error,SDImageCacheTypecacheType,BOOLfinished,NSURL*imageURL){NSLog(@"下載完成"); }];

對於初級來說，用sd_setImageWithURL:的若干個方法就可以實現很好的圖片緩存。

UIButton 的父類是UIControl UIControl的父類是UIView UIView的父類是 UIResponder

http狀態嗎：302 是請求重定向。500以上是服務器錯誤。400以上是請求鏈接錯誤或者找不到服務器。200以上是正確。100以上是請求接受成功。

HTTP Keep-Alive詳解[轉]

HTTP是一個請求<->響應模式的典型范例，即客戶端向服務器發送一個請求信息，服務器來響應這個信息。在老的HTTP版本中，每個請求都將被創建一個新的客戶端->服務器的連接，在這個連接上發送請求，然後接收請求。這樣的模式有一個很大的優點就是，它很簡單，很容易理解和編程實現;它也有一個很大的缺點就是，它效率很低，因此Keep-Alive被提出用來解決效率低的問題。

Keep-Alive功能使客戶端到服務器端的連接持續有效，當出現對服務器的後繼請求時，Keep-Alive功能避免了建立或者重新建立連接。市場上的大部分Web服務器，包括iPlanet、IIS和Apache，都支持HTTPKeep-Alive。對於提供靜態內容的網站來說，這個功能通常很有用。但是，對於負擔較重的網站來說，這裡存在另外一個問題：雖然為客戶保留打開的連接有一定的好處，但它同樣影響了性能，因為在處理暫停期間，本來可以釋放的資源仍舊被占用。當Web服務器和應用服務器在同一台機器上運行時，Keep-Alive功能對資源利用的影響尤其突出。此功能為HTTP 1.1預設的功能，HTTP 1.0加上Keep-Aliveheader也可以提供HTTP的持續作用功能。

Keep-Alive: timeout=5, max=100

timeout：過期時間5秒(對應httpd.conf裡的參數是：KeepAliveTimeout)，max是最多一百次請求，強制斷掉連接

就是在timeout時間內又有新的連接過來，同時max會自動減1，直到為0，強制斷掉。見下面的四個圖，注意看Date的值(前後時間差都是在5秒之內)!

HTTP/1.0

在HTTP/1.0版本中，並沒有官方的標准來規定Keep-Alive如何工作，因此實際上它是被附加到HTTP/1.0協議上，如果客戶端浏覽器支持Keep-Alive，那麼就在HTTP請求頭中添加一個字段Connection: Keep-Alive，當服務器收到附帶有Connection: Keep-Alive的請求時，它也會在響應頭中添加一個同樣的字段來使用Keep-Alive。這樣一來，客戶端和服務器之間的HTTP連接就會被保持，不會斷開(超過Keep-Alive規定的時間，意外斷電等情況除外)，當客戶端發送另外一個請求時，就使用這條已經建立的連接

HTTP/1.1

在HTTP/1.1版本中，官方規定的Keep-Alive使用標准和在HTTP/1.0版本中有些不同，默認情況下所在HTTP1.1中所有連接都被保持，除非在請求頭或響應頭中指明要關閉：Connection: Close ，這也就是為什麼Connection: Keep-Alive字段再沒有意義的原因。另外，還添加了一個新的字段Keep-Alive:，因為這個字段並沒有詳細描述用來做什麼，可忽略它

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，大部分服務器都會自動忽略，但是在未經測試之前是不可能知道一個服務器是否會這樣做。

1、常用的方法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=[NSURLURLWithString:@"http://avatar.csdn.net/2/C/D/1_totogo2010.jpg"];

NSData*data=[[NSDataalloc]initWithContentsOfURL:url];

UIImage*image=[[UIImagealloc]initWithData:data];

if(data!=nil){

dispatch_async(dispatch_get_main_queue(),^{

self.imageView.image=image;

});

}

});

運行顯示：

是不是代碼比NSThread NSOperation簡潔很多，而且GCD會自動根據任務在多核處理器上分配資源，優化程序。

系統給每一個應用程序提供了三個concurrent dispatch queues。這三個並發調度隊列是全局的，它們只有優先級的不同。因為是全局的，我們不需要去創建。我們只需要通過使用函數dispath_get_global_queue去得到隊列，如下：

dispatch_queue_tglobalQ=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

這裡也用到了系統默認就有一個串行隊列main_queue

dispatch_queue_tmainQ=dispatch_get_main_queue();

雖然dispatch queue是引用計數的對象，但是以上兩個都是全局的隊列，不用retain或release。

2、dispatch_group_async的使用

dispatch_group_async可以實現監聽一組任務是否完成，完成後得到通知執行其他的操作。這個方法很有用，比如你執行三個下載任務，當三個任務都下載完成後你才通知界面說完成的了。下面是一段例子代碼：

dispatch_queue_tqueue=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

dispatch_group_tgroup=dispatch_group_create();

dispatch_group_async(group,queue,^{

[NSThreadsleepForTimeInterval:1];

NSLog(@"group1");

});

dispatch_group_async(group,queue,^{

[NSThreadsleepForTimeInterval:2];

NSLog(@"group2");

});

dispatch_group_async(group,queue,^{

[NSThreadsleepForTimeInterval:3];

NSLog(@"group3");

});

dispatch_group_notify(group,dispatch_get_main_queue(),^{

NSLog(@"updateUi");

});

dispatch_release(group);

dispatch_group_async是異步的方法，運行後可以看到打印結果：

2016-09-25 16:04:16.737 gcdTest[43328:11303] group1

2016-09-25 16:04:17.738 gcdTest[43328:12a1b] group2

2016-09-25 16:04:18.738 gcdTest[43328:13003] group3

2016-09-25 16:04:18.739 gcdTest[43328:f803] updateUi

每個一秒打印一個，當第三個任務執行後，upadteUi被打印。

3、dispatch_barrier_async的使用

dispatch_barrier_async是在前面的任務執行結束後它才執行，而且它後面的任務等它執行完成之後才會執行

例子代碼如下：

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

dispatch_async(queue,^{

[NSThreadsleepForTimeInterval:2];

NSLog(@"dispatch_async1");

});

dispatch_async(queue,^{

[NSThreadsleepForTimeInterval:4];

NSLog(@"dispatch_async2");

});

dispatch_barrier_async(queue,^{

NSLog(@"dispatch_barrier_async");

[NSThreadsleepForTimeInterval:4];

});

dispatch_async(queue,^{

[NSThreadsleepForTimeInterval:1];

NSLog(@"dispatch_async3");

});

打印結果：

2016-09-25 16:20:33.967 gcdTest[45547:11203] dispatch_async1

2016-09-25 16:20:35.967 gcdTest[45547:11303] dispatch_async2

2016-09-25 16:20:35.967 gcdTest[45547:11303] dispatch_barrier_async

2016-09-25 16:20:40.970 gcdTest[45547:11303] dispatch_async3

請注意執行的時間，可以看到執行的順序如上所述。

4、dispatch_apply

執行某個代碼片段N次。

dispatch_apply(5, globalQ, ^(size_t index) {

// 執行5次

});

copy與retain：

1、copy其實是建立了一個相同的對象，而retain不是;

2、copy是內容拷貝，retain是指針拷貝;

3、copy是內容的拷貝 ,對於像NSString,的確是這樣，但是如果copy的是一個NSArray呢?這時只是copy了指向array中相對應元素的指針.這便是所謂的"淺復制".

4、copy的情況：NSString *newPt = [pt copy];

此時會在堆上重新開辟一段內存存放@"abc" 比如0X1122 內容為@"abc 同時會在棧上為newPt分配空間比如地址：0Xaacc 內容為0X1122 因此retainCount增加1供newPt來管理0X1122這段內存;

assign與retain：

1、assign: 簡單賦值，不更改索引計數;

2、assign的情況：NSString *newPt = [pt assing];

此時newPt和pt完全相同地址都是0Xaaaa 內容為0X1111 即newPt只是pt的別名，對任何一個操作就等於對另一個操作，因此retainCount不需要增加;

3、assign就是直接賦值;

4、retain使用了引用計數，retain引起引用計數加1, release引起引用計數減1，當引用計數為0時，dealloc函數被調用，內存被回收;

5、retain的情況：NSString *newPt = [pt retain];

此時newPt的地址不再為0Xaaaa，可能為0Xaabb 但是內容依然為0X1111。因此newPt 和 pt 都可以管理"abc"所在的內存，因此 retainCount需要增加1;

readonly：

1、屬性是只讀的，默認的標記是讀寫，如果你指定了只讀，在@implementation中只需要一個讀取器。或者如果你使用@synthesize關鍵字，也是有讀取器方法被解析

readwrite：

1、說明屬性會被當成讀寫的，這也是默認屬性。設置器和讀取器都需要在@implementation中實現。如果使用@synthesize關鍵字，讀取器和設置器都會被解析;

nonatomic：

1、非原子性訪問，對屬性賦值的時候不加鎖，多線程並發訪問會提高性能。如果不加此屬性，則默認是兩個訪問方法都為原子型事務訪問;

weak and strong property (強引用和弱引用的區別)：

1、weak 和 strong 屬性只有在你打開ARC時才會被要求使用，這時你是不能使用retain release autorelease 操作的，因為ARC會自動為你做好這些操作，但是你需要在對象屬性上使用weak 和strong,其中strong就相當於retain屬性，而weak相當於assign。

2、只有一種情況你需要使用weak(默認是strong)，就是為了避免retain cycles(就是父類中含有子類{父類retain了子類}，子類中又調用了父類{子類又retain了父類}，這樣都無法release)

3、聲明為weak的指針，指針指向的地址一旦被釋放，這些指針都將被賦值為nil。這樣的好處能有效的防止野指針。

ARC(Automatic Reference Counting):

1、就是代碼中自動加入了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 自動釋放池是什麼,如何工作

當您向一個對象發送一個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 。

"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 可以采用另一種簡化語法，可以在一個標簽中同時表示起始和結束標簽。這種語法是在大於符號之前緊跟一個斜線(/)，例如。XML解析器會將其翻譯成。

3 標簽必須按合適的順序進行嵌套，所以結束標簽必須按鏡像順序匹配起始標簽，例如this is asamplestring。這好比是將起始和結束標簽看作是數學中的左右括號：在沒有關閉所有的內部括號之前，是不能關閉外面的括號的。

4 所有的特性都必須有值。

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

45union u

{

double a;

int b;

};

union u2

{

char a[13];

int b;

};

union u3

{

char a[13];

char b;

};

cout<

都知道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<

同樣是兩個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的話就是小端了吧。

堆和棧上的指針

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

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

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

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的參數不能為實型。

華為

1、局部變量能否和全局變量重名?

答：能，局部會屏蔽全局。要用全局變量，需要使用"::"

局部變量可以與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而

不會用到全局變量。對於有些編譯器而言，在同一個函數內可以定義多個同名的局部變

量，比如在兩個循環體內都定義一個同名的局部變量，而那個局部變量的作用域就在那

個循環體內

2、如何引用一個已經定義過的全局變量?

答：extern

可以用引用頭文件的方式，也可以用extern關鍵字，如果用引用頭文件方式來引用某個

在頭文件中聲明的全局變理，假定你將那個變寫錯了，那麼在編譯期間會報錯，如果你

用extern方式引用時，假定你犯了同樣的錯誤，那麼在編譯期間不會報錯，而在連接期

間報錯

3、全局變量可不可以定義在可被多個.C文件包含的頭文件中?為什麼?

答：可以，在不同的C文件中以static形式來聲明同名全局變量。

可以在不同的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦

初值，此時連接不會出錯

4、語句for( ;1 ;)有什麼問題?它是什麼意思?

答：和while(1)相同。

5、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;

}]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++的函數了試題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;