iOS面試題，但願給面試的同窗一點幫助。
iOS基礎面試題php
1.用objective-c寫一個插入法排序html
2.寫一個NSString類的實現java
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;ios
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding{c++
NSString *obj;程序員
obj = [self allocWithZone: NSDefaultMallocZone()];面試
obj = [obj initWIthCString: nullTerminatedCString encoding: encoding];objective-c
return AUTORELEASE(obj);sql
}數據庫
3.寫一個委託的interface
#import <Foundation/Foundation.h>
@protocol MyDelegate;//聲明
@interface MyClass : NSObject
{
id <MyDelegate> delegate;
}
@end
@protocol MyDelegate//委託方法
- (void)didJobs:(NSArray *)args;
@end
4.obj-c有私有方法麼?私有變量呢
在Objective-C有私有方法，有靜態方法和實例方法。也有私有變量。
@interface MyClass (Private)
- (void)testPrivate;
@end
objective-c - 類裏面的方法只有兩種, 靜態方法和實例方法. 這彷佛就不是完整的面向對象了,按照OO的原則就是一個對象只暴露有用的東西. 若是沒有了私有方法的話, 對於一些小範圍的代碼重用就不那麼順手了. 在類裏面聲名一個私有方法
@interface Controller : NSObject { NSString *something; }
+ (void)thisIsAStaticMethod;
- (void)thisIsAnInstanceMethod;
@end
@interface Controller (private) -
(void)thisIsAPrivateMethod;
@end
@private能夠用來修飾私有變量
在Objective‐C中，全部實例變量默認都是私有的，全部實例方法默認都是公有的
5.#import跟#include的區別?
預編譯指令Objective-C：#import C，C++：#include #import由gcc編譯器支持
在 Objective-C 中，#import 被當成 #include 指令的改良版原本使用。除此以外，#import 肯定一個文件只能被導入一次，這使你在遞歸包含中不會出現問題。
使用哪個仍是由你來決定。通常來講，在導入 Objective-C 頭文件的時候使用 #import，包含 C 頭文件時使用 #include。好比：
#import <foundation /Foundation.h>
#include <asl .h>
#include <mach /mach.h>
#import比起#include的好處就是不會引發交叉編譯
擴展:@class是用來作類引用的
@class就是告訴編譯器有這麼一個類，至於類的定義是啥不知道
@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import
舉個例子說明：
在ClassA.h中
#import ClassB.h 至關於#include整個.h頭文件。若是有不少.m文件#import ClassA.h，那麼編譯的時候這些文件也會#import ClassB.h增長了不必的#import，浪費編譯時間。在大型軟件中，減小.h文件中的include是很是重要的。
若是隻是@class ClassB 那就沒有include ClassB.h。僅須要在須要用到ClassB的ClassA.m文件中 #import ClassB.h
@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import 而#import比起#include的好處就是不會引發重複包含
6.請寫出你對MVC模式的理解
答：MVC是一種設計模式，考慮三種對象：模型對象、視圖對象和控制器對象。模型對象負責應用程序的數據和定義操做數據的邏輯；視圖對象知道如何顯示應用程序的模型數據；控制器對象是M與V之間的協調者。實現了功能模塊和顯示模塊的分離，同時它還提升了應用系統的可維護性、可擴展性、可移植性和組件的可複用性。
7.什麼是鍵-值,鍵路徑是什麼
答：模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。
鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相關對象的特定屬性。
許多編程技術都基於間接機制，不是OC特性，而是Cocoa提供的一種特性，KVC是一種間接更改對象狀態的方式，其實現方法是使用字符串描述要更改的對象狀態部分。
除了經過鍵設置值外，鍵值編碼還支持指定鍵路徑，像文件系統路徑同樣，能夠遵循一系列關係來指定該路徑。
For example, the key path address.streetwould get the value of the address property from the receiving object, and then determine the street property relative to the address object.
8.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.
9.什麼是目標-動做機制
目標是動做消息的接收者。一個控件，或者更爲常見的是它的單元，以插座變量（參 見"插座變量"部分）
的形式保有其動做消息的目標。動做是控件發送給目標的消息，或者從目標的角度看，它是目標爲了響應動做而實現 的方法。程序須要某些機制來進行事件和指令的翻譯。這個機制就是目標-動做機制
10.請列舉你熟悉cocoa touch框架(至少三個)
答：Core Animation 經過 Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。 Core Audio Core Audio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。 Core Data 提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用或大或小的數據模型。
11.請寫出obj-c的內存管理代碼
12.自動釋放池是什麼,如何工做
當您向一個對象發送一個autorelease 消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當 程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。
1. ojc-c 是 經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬.
2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的.
3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.
13.obj-c的優缺點
objc優勢： 1) Cateogies 2) Posing 3) 動態識別 4) 指標計算 5）彈性訊息傳遞
6) 不是一個過分複雜的 C 衍生語言 7) Objective-C 與 C++ 可混合編程
缺點: 1) 不支援命名空間 2) 不支持運算符重載 3） 不支持多重繼承 4） 使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。
14.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，非原子性訪問，不加同步，多線程併發訪問會提升性能。注意，若是不加此屬性，則默認是兩個訪問方法都爲原子型事務訪問。鎖被加到所屬對象實例級。
15.在一個對象的方法裏面:
self.name = 「object」; 和 name ＝」object」; 有什麼不一樣嗎?
16.ViewController 的 loadView, viewDidLoad, viewDidUnload 分別是在何時調用的？在自定義ViewController的時候這幾個函數裏面應該作什麼工做？
18.ViewController 的 didReceiveMemoryWarning
2. 如下爲Windows NT下的32位C++程序，請計算sizeof的值 void Func ( char str[100] ) { sizeof( str ) = ? } void *p = malloc( 100 ); sizeof ( p ) = ?
這題 很常見了,Func ( char str[100] )函數中數組名做爲函數形參時，在函數體內，數組名失去了自己的內涵，僅僅只是一個指針；在失去其內涵的同時，它還失去了其常量特性，能夠做自增、自減等 操做，能夠被修改。Windows NT 32位平臺下，指針的長度（佔用內存的大小）爲4字節，故sizeof( str ) 、sizeof ( p ) 都爲4。
3.還 是考指針,不過我對cocoa的代碼仍是不太熟悉
大概是這樣的
- （void）*getNSString(const NSString * inputString)
{
inputString = @"This is a main test\n";
return ;
}
-main(void)
{
NSString *a=@"Main";
NSString *aString = [NSString stringWithString:@"%@",getNSString(a)];
NSLog(@"%@\n", aString);
}
最後問輸出的字符串:NULL,output在 函數返回後，內存已經被釋放。
4.用預處理指令#define聲 明一個常數，用以代表1年中有多少秒（忽略閏年問題）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在這想看到幾件事 情： ?; #define 語法的基本知識（例如：不能以分號結束，括號的使用，等等） ?; 懂得預處理器將爲你計算常數表達式的值，所以，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。 ?; 意識到這個表達式將使一個16位機的整型數溢出-所以要用到長整型符號L,告訴編譯器這個常數是的長整型數。 ?; 若是你在你的表達式中用到UL（表示無符號長整型），那麼你有了一個好的起點。記住，第一印象很重要
寫一個" 標準"宏MIN ，這個宏輸入兩個參數並返回較小的一個。
#define MIN(A,B) （（A） <= (B) ? (A) : (B)) 這 個
測試是爲下面的目的而設的： ?; 標識#define在宏中應用的基本知識。這是很重要的，由於直到嵌入(inline)操做符變爲
標準C的一部分，宏是方便產生嵌入代碼的惟一方 法， 對於嵌入式系統來講，爲了能達到要求的性能，嵌入代碼常常是必須的方法。 ?;
三重條件操做符的知識。這個操做符存在C語言中的緣由是它使得編譯器能產生比 if-then-else
更優化的代碼，瞭解這個用法是很重要的。 ?; 懂得在宏中當心地把參數用括號括起來 ?;
我也用這個問題開始討論宏的反作用，例如：當你寫下面的代碼時會發生什麼事？ least = MIN(*p++, b);
結果是： ((*p++) <= (b) ? (*p++) : (*p++)) 這個表達式會產生反作用，指針p會做三次++自增操做。
5.寫一個委託的 interface
@protocol MyDelegate;
@interface MyClass: NSObject
{
id <MyDelegate> delegate;
}
// 委託方法
@protocol MyDelegate
- (void)didJobs:(NSArray *)args;
@end
6. 寫一個NSString類的實現
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id) stringWithCString: (const char*)nullTerminatedCString encoding: (NSStringEncoding)encoding { NSString *obj;
obj = [self allocWithZone: NSDefaultMallocZone()]; obj = [obj initWithCString: nullTerminatedCString encoding: encoding]; return AUTORELEASE(obj); }
7.obj-c有多重繼承麼?不是的話有什麼替代方法?
cocoa 中全部的類都是NSObject 的子類
多繼承在這裏是用protocol 委託代理 來實現的 你不用去考慮繁瑣的多繼承 ,虛基類的概念. ood的多態特性 在 obj-c 中經過委託來實現.
8.obj- c有私有方法麼?私有變量呢
objective-c - 類裏面的方法只有兩種, 靜態方法和實例方法. 這彷佛就不是完整的面向對象了,按照OO的原則就是一個對象只暴露有用的東西. 若是沒有了私有方法的話, 對於一些小範圍的代碼重用就不那麼順手了. 在類裏面聲名一個私有方法
@interface Controller : NSObject { NSString *something; }
+ (void)thisIsAStaticMethod;
- (void)thisIsAnInstanceMethod;
@end
@interface Controller (private) -
(void)thisIsAPrivateMethod;
@end
@private能夠用來修飾私有變 量
在Objective‐C中，全部實例變量默認都是私 有的，全部實例方法默認都 是公有的
9.關鍵字const有什麼含 意？修飾類呢?static的做 用,用於類呢?還有extern c的做用
const 意味着"只讀"，下面的聲明都是什麼意思？ const int a; int const a; const int *a; int * const a; int const * a const;
前兩個的做用是同樣，a是一個常整型數。第三個意味着a是一個指向常整型數的指 針（也就是，整型數是不可修改的，但指針能夠）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是能夠修改的，但指針是不可修改 的）。最後一個意味着a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。
結論：
?; 關鍵字const的做用是爲給讀你代碼的人傳達很是有用的信息，實際上，聲明一個參數爲常量是爲了告訴了用戶這個參數的應用目的。若是 你曾花不少 時間清理其它人留下的垃圾，你就會很快學會感謝這點多餘的信息。（固然，懂得用const的程序員不多會留下的垃圾讓別人來清 理的。） ?; 經過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。 ?; 合理地使用關鍵字const能夠使編譯器很天然地保護那些不但願被改變的參數，防止其被無心的代碼修改。簡而言之，這樣能夠減小bug的出現。
（1）欲阻止一個變量被改變，能夠使用 const 關鍵字。在定義該 const 變量時，一般須要對它進行初 始化，由於之後就沒有機會再去改變它了； （2）對指針來講，能夠指定指針自己爲 const，也能夠指定指針所指的數據爲 const，或兩者同時指 定爲 const； （3）在一個函數聲明中，const 能夠修飾形參，代表它是一個輸入參數，在函數內部不能改變其值； （4）對於類的成員函數，若指定其爲 const 類型，則代表其是一個常函數，不能修改類的成員變量； （5）對於類的成員函數，有時候必須指定其返回值爲 const 類型，以使得其返回值不爲「左值」。
關鍵字volatile有什麼含意?並給出三個不一樣的例子。
一個定義爲 volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到 這個變量時必須 每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子：
?; 並行設備的硬件寄存器（如：狀態寄存器） ?; 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables) ?; 多線程應用中被幾個任務共享的變量
?; 一個參數既能夠是const還能夠是volatile嗎？解釋爲何。 ?; 一個指針能夠是volatile 嗎？解釋爲何。 下 面是答案： ?; 是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。 ?; 是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。
static 關鍵字的做用：
（1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次， 所以其值在下次調用時仍維持上次的值； （2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問； （3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明 它的模塊內； （4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝； （5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。
extern "C" 的做用
（1）被 extern "C"限定的函數或變量是 extern 類型的；
extern 是 C/C++語言中代表函數和全局變量做用範圍（可見性）的關鍵字，該關鍵字告訴編譯器， 其聲明的函數和變量能夠在本模塊或 其它模塊中使用。
（2）被 extern "C"修飾的變量和函數是按照 C 語言方式編譯和鏈接的；
extern "C"的慣用法
（1）在 C++中引用 C 語言中的函數和變量，在包含 C 語言頭文件（假設爲 cExample.h）時，需進 行下列處理： extern "C" { #include "cExample.h" } 而在 C 語言的頭文件中，對其外部函數只能指定爲 extern 類型，C 語言中不支持 extern "C"聲明， 在.c 文件中包含了 extern "C"時會出現編譯語法錯誤。
（2）在 C 中引用 C++語言中的函數和變量時，C++的頭文件需添加 extern "C"，可是在 C 語言中不 能直接引用聲明瞭 extern "C"的該頭文件，應該僅將 C 文件中將 C++中定義的 extern "C"函數聲明爲 extern 類型。
10.爲何標準頭文件都有相似如下的結構？ #ifndef __INCvxWorksh #define __INCvxWorksh #ifdef __cplusplus extern "C" { #endif /*...*/ #ifdef __cplusplus } #endif #endif /* __INCvxWorksh */
顯然，頭文件中的編譯宏 「#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif」 的做用 是防止該頭文件被重複引用。
11.#import 跟#include的區別,@class呢?
@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文 件中仍是須要使用#import
而#import比 起#include的好處就是不會引發交叉編譯
12.MVC 模式的理解
MVC設計模式考慮三種對 象：模型對象、視圖對象、和控制器對象。模型對象表明 特別的知識和專業技能，它們負責保有應用程序的數據和定義操做數據的邏輯。視圖對象知道如何顯示應用程序的模型數據，並且可能容許用戶對其進行編輯。控制 器對象是應用程序的視圖對象和模型對象之間的協調者。
13. 線程與進程的區別和聯繫?
進程和線程都是由操做系統所體會的程序運行的基本 單元，系統利用該基本單元實現系統對應用的併發性。
程和線程的主要差異在於它們是不一樣的操做系統資源 管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變 量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一 些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。
14.列舉幾種進程的同步機制，並比較其優缺點。
答案： 原子操做 信號量機制 自旋鎖 管程，會合，分佈式系統 進程之間通訊的途徑
答案：共享存儲系統消息傳遞系統管道：以文件系統爲基礎 進 程死鎖的緣由
答案：資源競爭及進程推 進順序非法 死鎖的4個必要條 件
答案：互斥、請求保持、不可剝奪、 環路 死鎖的處理
答案：鴕鳥策略、預防策略、避免策略、檢測與解除死鎖
15.堆和棧 的區別
管 理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。
申請大 小： 棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統 預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示 overflow。所以，能從棧得到的空間較小。 堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地 址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。
碎 片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個 問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出
分配方式：堆都是動態分配的，沒有靜態 分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由 alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。
分配效率：棧是機器系統提 供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的 效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。
16.什麼是鍵-值,鍵路徑是什麼
模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵 來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。
鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性 質序列。第一個鍵的 性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型 實現的方式指定相關 對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相 關對象的特定屬性。
For example, the key path address.streetwould get the value of the address property from the receiving
object, and then determine the street property relative to the address object.
19.cocoa touch框架
iPhone OS 應用程序的基礎 Cocoa Touch 框架重用了許多 Mac 系統的成熟模式，可是它更多地專一於觸摸的接口和優化。UIKit 爲您提供了在 iPhone OS 上實現圖形，事件驅動程序的基本工具，其創建在和 Mac OS X 中同樣的 Foundation 框架上，包括文件處理，網絡，字符串操做等。
Cocoa Touch 具備和 iPhone 用戶接口一致的特殊設計。有了 UIKit，您能夠使用 iPhone OS 上的獨特的圖形接口控件，按鈕，以及全屏視圖的功能，您還能夠使用加速儀和多點觸摸手勢來控制您的應用。
各色俱全的框架 除了 UIKit 外，Cocoa Touch 包含了建立世界一流 iPhone 應用程序須要的全部框架，從三維圖形，到專業音效，甚至提供設備訪問 API 以控制攝像頭，或經過 GPS 獲知當前位置。Cocoa Touch 既包含只須要幾行代碼就能夠完成所有任務的強大的 Objective-C 框架，也在須要時提供基礎的 C 語言 API 來直接訪問系統。這些框架包括：
Core Animation
經過 Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。
Core Audio
Core Audio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。
Core Data
提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用 或大或小的數據模型。
功能列表：框架分類
下面是 Cocoa Touch 中一小部分可用的框架：
音頻和 視頻Core AudioOpenALMedia LibraryAV Foundation數據管理Core DataSQLite
圖 形和動畫Core AnimationOpenGL ESQuartz 2D網絡/li>BonjourWebKitBSD Sockets
用 戶應用Address BookCore LocationMap KitStore Kit
21.自動釋放池是什麼,如何工做
當您向一個對象發送一個autorelease消息時，Cocoa就會將該對 象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置 時，自動釋放池就會被釋放，池中的全部對象也就被釋放。
1. ojc-c 是經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬. 2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的. 3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數 減一.
22.類工廠方法是什麼
類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中， 返回被建立的對象，並 進行自動釋放處理。這些方法的形式是+ (type)className...（其中 className不包括任何前綴）。
工廠方法可能不 僅僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠 爲初始化過程提供對 象的分配信息。
類工廠方法的 另外一個目的是使類（好比NSWorkspace）提供單件實例。雖 然init...方法能夠確認一 個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。 工廠 方法則能夠避免爲可能沒有用的對象盲目分配內存。
23.單件實例是什麼
Foundation 和 Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager 和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配 和初始化。 單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比 NSWorkspace），就應該產生 一個單件實例，而不是多個實例；若是未來某一天可能有多個實例，您可 以使用單件實例機制，而不是工廠方法或函數。
24.動態綁定—在運行時肯定要調用的方法
動 態綁定將調用方法的肯定也推遲到運行時。在編譯時，方法的調用並不和代碼綁定 在一塊兒，只有在消實發送出來以後，才肯定被調用的代碼。經過動態類型和動態綁定技術，您的代碼每次執行均可以獲得不一樣的結果。運行時因子負責肯定消息的接 收者和被調用的方法。 運行時的消息分發機制爲動態綁定提供支持。當您向一個動態類型肯定了的對象發送消息時，運行環境系統會經過接收者的isa指針定位對象的類，並以此爲起點 肯定被調用的方法，方法和消息是動態綁定的。並且，您沒必要在Objective-C 代碼中作任何工做，就能夠自動獲取動態綁定的好處。您在每次發送消息時，
特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而 透明地發生。
25.obj-c的優缺 點
objc優勢： 1) Cateogies 2) Posing 3) 動態識別 4) 指標計算 5）彈性訊息傳遞 6) 不是一個過分複雜的 C 衍生語言 7) Objective-C 與 C++ 可混合編程 缺點: 1) 不支援命名空間 2) 不支持運算符重載 3） 不支持多重繼承 4） 使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。
26.sprintf,strcpy,memcpy使用上有什 麼要注意的地方
strcpy是一個字符串拷貝的函數，它的函數原型爲strcpy(char *dst, const char *src);
將 src開始的一段字符串拷貝到dst開始的內存中去，結束的標誌符號爲 '\0'，因爲拷貝的長度不是由咱們本身控制的，因此這個字符串拷貝很容易出錯。具有字符串拷貝功能的函數有memcpy，這是一個內存拷貝函數，它的函 數原型爲memcpy(char *dst, const char* src, unsigned int len);
將長度爲len的一段內存，從src拷貝到dst中去，這個函數的長度可控。但 是會有內存疊加的問題。
sprintf是格式化函數。將 一段數據經過特定的格式，格式化到一個字符串緩 衝區中去。sprintf格式化的函數的長度不可控，有可能格式化後的字符串會超出緩衝區的大小，形成溢出。
27. 用變量a給出下面的定義
a) 一個整型數（An integer） b)一 個指向整型數的指針（ A pointer to an integer） c)一個指向指針的的指針，它指向的指針是指向一個整型數（ A pointer to a pointer to an intege）r d)一個有10個整型數的數組（ An array of 10 integers） e) 一個有10個指針的數組，該指針是指向一個整型數的。（An array of 10 pointers to integers） f) 一個指向有10個整型數數組的指針（ A pointer to an array of 10 integers） g) 一個指向函數的指針，該函數有一個整型參數並返回一個整型數（A pointer to a function that takes an integer as an argument and returns an integer） h) 一個有10個指針的數組，該指針指向一個函數，該函數有一個整型參數並返回一個整型數（ An array of ten pointers to functions t hat take an integer argument and return an integer ） 答 案是： 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 functions that take an integer argument and return an integer
Iphone基礎面試題
1.寫一個NSString類的實現
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding{
NSString *obj;
obj = [self allocWithZone: NSDefaultMallocZone()];
obj = [obj initWIthCString: nullTerminatedCString encoding: encoding];
return AUTORELEASE(obj);
}
2.寫一個委託的interface
答：
@protocol MyDelegate;
@interface MyClass: NSObject
{
id <MyDelegate> delegate;
}
// 委託方法
@protocol MyDelegate
- (void)didJobs:(NSArray *)args;
@end
3.請寫出你對MVC模式的理解
答：MVC模式考慮三種對象：模型對象、視圖對象和控制器對象。模型對象負責應用程序的數據和定義操做數據的邏輯；視圖對象知道如何顯示應用程序的模型數據；控制器對象是M與V之間的協調者。
4.什麼是鍵-值,鍵路徑是什麼
答：模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。
鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相關對象的特定屬性。
5.請列舉你熟悉cocoa touch框架(至少三個)
答：
Core Animation
經過 Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。
Core Audio
Core Audio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。
Core Data
提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用或大或小的數據模型。
功能列表：框架分類
下面是 Cocoa Touch 中一小部分可用的框架：
- 音頻和視頻 Core Audio OpenAL Media Library AV Foundation
- 數據管理 Core Data SQLite
- 圖形和動畫 Core Animation OpenGL ES Quartz 2D
- 網絡> Bonjour WebKit BSD Sockets
- 用戶應用 Address Book Core Location Map Kit Store Kit
6.自動釋放池是什麼,如何工做
當您向一個對象發送一個autorelease 消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當 程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。
1. ojc-c 是 經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬.
2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的.
3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.
7.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，非原子性訪問，不加同步，多線程併發訪問會提升性能。注意，若是不加此屬性，則默認是兩個訪問方法都爲原子型事務訪問。鎖被加到所屬對象實例級。
8.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 。
9.類工廠方法是什麼
類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中， 返回被建立的對象，並 進行自動釋放處理。這些方法的形式是+ (type)className...（其中 className不包括任何前綴）。
工廠方法可能不 僅僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠 爲初始化過程提供對 象的分配信息。
類工廠方法的 另外一個目的是使類（好比NSWorkspace）提供單件實例。雖 然init...方法能夠確認一 個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。 工廠 方法則能夠避免爲可能沒有用的對象盲目分配內存。
|
|
1.淺複製和深複製的區別？//淺拷貝和深拷貝
答案：
淺層複製（copy）：只複製指向對象的指針，而不復制引用對象自己。//經過對象的指針來訪問這個對象
深層複製（mutableCopy）：複製引用對象自己 意思就是有個A對象，複製一份後獲得A_copy對象後，對於淺複製來講，A和A_copy指向的是同一個內存資源，複製的只不過是是一個指針，對象自己資源 仍是隻有一份，那若是咱們對A_copy執行了修改操做,那麼發現A引用的對象一樣被修改，這其實違背了咱們複製拷貝的一個思想。深複製就好理解了,內存中存在了 兩份獨立對象自己。//當修改A時，A copy不變。
打個比喻：一、淺拷貝就是：你掛了，你媽媽喊你回家吃飯時找不到人了，她很傷心。二、深拷貝就是：你克隆了一個你本身：你掛了、你兄弟還在，你媽媽喊你回家吃飯時能找到人。因此、孩子，安全起見、深拷貝吧，記得內存管理就是了。
2.類別的做用？繼承和類別在實現中有何區別？
答案：category 能夠在不獲悉，不改變原來代碼的狀況下往裏面添加新的方法，只能添加，不能刪除修改。// category:類、種類
而且若是類別和原來類中的方法產生名稱衝突，則類別將覆蓋原來的方法，由於類別具備更高的優先級。//類別跟類的優先級
類別主要有3個做用：
(1)將類的實現分散到多個不一樣文件或多個不一樣框架中。
(2)建立對私有方法的前向引用。
(3)向對象添加非正式協議。
繼承能夠增長，修改或者刪除方法，而且能夠增長屬性。 //非正式協議:是使用類別category來實現，非正式協議是NSObject的一個類別，這樣任何類的對象均可以做爲委託對象來使用，它能夠列出對象可以執行的全部方法，這樣用來實現委託， 咱們能夠使用選擇器來判斷該非正式協議中是否有這個方法。 正式協議:是一個命名的方法列表，與非正式協議相比不一樣的是，它要求顯示的採用協議，採用協議的方法是在類的＠ｉｎｔｅｒｆａｃｅ聲明中列出協議的名稱，此時，實現協議的類應該遵照協議，承諾實現協議中的全部方法。
3 類別和類擴展的區別。
答案：category和extensions的不一樣在於 後者能夠添加屬性。另外後者添加的方法是必需要實現的。 extensions能夠認爲是一個私有的Category。
4. oc中的協議和java中的接口概念有何不一樣？
答案：OC中的代理有2層含義，官方定義爲 formal和informal protocol。前者和Java接口同樣。 informal protocol中的方法屬於設計模式考慮範疇，不是必須實現的，可是若是有實現，就會改變類的屬性。 其實關於正式協議，類別和非正式協議我很早前學習的時候大體看過，也寫在了學習教程裏 「非正式協議概念其實就是類別的另外一種表達方式「這裏有一些你可能但願實現的方法，你能夠使用他們更好的完成工做」。 這個意思是，這些是可選的。好比我門要一個更好的方法，咱們就會申明一個這樣的類別去實現。而後你在後期能夠直接使用這些更好的方法。 這麼看，總以爲類別這玩意兒有點像協議的可選協議。" 如今來看，其實protocal已經開始對二者都統一和規範起來操做，由於資料中說「非正式協議使用interface修飾「， 如今咱們看到協議中兩個修飾詞：「必須實現(@requied)」和「可選實現(@optional)」。
5.什麼是KVO 和 KVC?
答案：kvc:鍵 - 值編碼是一種間接訪問對象的屬性使用字符串來標識屬性，而不是經過調用存取方法，直接或經過實例變量訪問的機制。//KVC運用了一個isa-swizzling技術。isa-swizzling就是類型混合指針機制。
KVC主要經過isa-swizzling，來實現其內部查找定位的。isa指針,就是is a kind of的意思,指向維護分發表的對象的類。該分發表實際上包含了指向實現類中的方法的指針，和其它數據。
kvo（Key-Value Observing）:鍵值觀察機制，他提供了觀察某一屬性變化的方法，極大的簡化了代碼。 用過的一個地方是對於按鈕點擊變化狀態的的監控。 好比我自定義的一個button。 //當屬性改變時KVO回提供自動的消息通知。每次屬性改變了就會發送消息通知。這是由於當這個方案已經被明肯定義，得到框架級支持，能夠方便的採用，開法人員不須要設計本身的觀察這模型，能夠直接在工程裏使用。KOV的架構能夠支持多個觀察者觀察同一個屬性，以及相關值。
[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.代理的做用？
答案：代理的目的是改變或傳遞控制鏈。容許一個類在某些特定時刻通知到其餘類，而不須要獲取到那些類的指針。能夠減小框架複雜度。
7.oc中可修改和不能夠修改類型。
答案：就是可動態添加修改和不可動態添加修改同樣。 好比NSArray和NSMutableArray。前者在初始化後的內存控件就是固定不可變的，後者能夠添加等，能夠動態申請新的內存空間。
8.咱們說的oc是動態運行時語言是什麼意思？
答案：多態。 主要是將數據類型的肯定由編譯時，推遲到了運行時。 這個問題其實淺涉及到兩個概念，運行時和多態。 運行時機制使咱們直到運行時纔去決定一個對象的類別，以及調用該類別對象指定方法。 多態：不一樣對象以本身的方式響應相同的消息的能力叫作多態。 //都用有一個相同的方法，不一樣的對象以本身的方式響應了相同的消息. 所以也能夠說，運行時機制是多態的基礎
9.通知和協議的不一樣之處？
答案：協議有控制鏈(has-a)的關係，通知沒有。//通知:它能夠一對多，一條消息能夠發送給多個消息接受者,可是不會處理消息 控制鏈：單一擁有和可控制的對應關係。
10.關於多態性
答案：多態，子類指針能夠賦值給父類。 對象不只僅能夠已自己的類型存在，也能夠做爲其父類類型存在。 多態性是容許將父對象設置成爲和一個或多個它的子對象相等的技術， 多態性使得可以利用同一類(基類)類型的指針來引用不一樣類的對象,以及根據所引用對象的不一樣,以不一樣的方式執行相同的操做.
11.說說響應鏈
答案： 事件響應鏈。包括點擊事件，畫面刷新事件等。在視圖棧內從上至下，或者從下之上傳播。
12. frame和bounds有什麼不一樣？
答案:frame指的是：該view在父view座標系統中的位置和大小。（參照點是父親的座標系統）//frame:框架、結構
bounds指的是：該view在自己座標系統中 的位置和大小。（參照點是自己座標系統）//bounds:界限
14. NSOperation隊列
操做和操做隊列，基本能夠當作java中的線程和線程池的概念。用於處理ios多線程開發的問題。 網上部分資料提到一點是，雖然是queue，可是卻並非帶有隊列的概念，放入的操做並不是是按照嚴格的先進現出。 這邊又有個疑點是，對於隊列來講，先進先出的概念是Afunc添加進隊列，Bfunc緊跟着也進入隊列，Afunc先執行這個是必然的， 可是Bfunc是等Afunc徹底操做完之後，B纔開始啓動而且執行，所以隊列的概念離亂上有點違背了多線程處理這個概念。 可是轉念一想其實能夠參考銀行的取票和叫號系統。 所以對於A比B先排隊取票可是B率先執行完操做，咱們亦然能夠感性認爲這仍是一個隊列。 可是後來看到一票關於這操做隊列話題的文章，其中有一句提到 「由於兩個操做提交的時間間隔很近，線程池中的線程，誰先啓動是不定的。」 瞬間以爲這個queue名字有點忽悠人了，還不如pool~ 綜合一點，咱們知道他能夠比較大的用處在於能夠幫組多線程編程就行了。
15.是否在一個視圖控制器中嵌入兩個tableview控制器？
答案：一個視圖控制只提供了一個View視圖，理論上一個tableViewController也不能放吧， 只能說能夠嵌入一個tableview視圖。而是宏觀的表示視圖控制者，那咱們卻是能夠把其當作一個視圖控制者，它能夠控制多個視圖控制器，好比TabbarController
16. 一個tableView是否能夠關聯兩個不一樣的數據源？你會怎麼處理？ 答案：首先從代碼來看，數據源如何關聯上的，實際上是在數據源關聯的代理方法裏實現的。
-(UITableViewCell*)cellForRowAtIndexPath:(NSIndexPath*)indexPath
{
if(indexPath.section == 0)
{
}
if(indexPath.section == 1)
{
}
}
17. 什麼是id類型
答案：id類型的變量能夠存聽任何數據類型的對象。在內部處理上，這種類型被定義爲指向對象的指針，其實是一個指向這種對象的實例變量的指針。 例如：id number 將number聲明爲id類型的變量。可聲明的方法使其具備id類型的返回值，以下：
-（id）newObject；(int)type; 這個程序聲明瞭一個名爲newObject的實例方法，它具備名爲type的單個整型參數並有id類型的返回值。應該注意的是，對返回值和參數類型聲明來講，id是默認的類型。 id類型是objetive-c中很是中藥店額數據類型，它是多態和動態綁定的基礎。
18.寫一個NSString類的實現
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding
{
NSString *obj;
obj = [self allocWithZone:NSDefaultMallocZone()];
obj = [obj initWIthCString:nullTerminatedCString encoding: encoding];
return AUTORELEASE(obj);
}
19.寫一個委託的interface
答：
@protocol MyDelegate;
@interface MyClass: NSObject
{
id <MyDelegate> delegate;
}
// 委託方法
@protocol MyDelegate
- (void)didJobs:(NSArray *)args;
@end
20.請寫出你對MVC模式的理解
答：MVC模式考慮三種對象：模型對象、視圖對象和控制器對象。 模型對象負責應用程序的數據和定義操做數據的邏輯； 視圖對象知道如何顯示應用程序的模型數據； 控制器對象是M與V之間的協調者。
21.什麼是鍵-值,鍵路徑是什麼
答：模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。 視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中， 同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行 這樣的查找—它是一種間接訪問對象屬性的機制。 鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接 在一塊兒的對象性質序列。第一個鍵的性質是由先前的性質決定的，接下來 每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型實現的 方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意 深度的路徑，使其指向相關對象的特定屬性。
22.請列舉你熟悉cocoa touch框架(至少三個)
答： Core Animation
經過 Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程 模型來建立豐富的用戶體驗。
Core Audio Core Audio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用 程序添增強大的音頻功能。
Core Data 提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理 任何應用或大或小的數據模型。
功能列表：框架分類
下面是 Cocoa Touch 中一小部分可用的框架：
音頻和視頻:
Core Audio
OpenAL
Media Library
AV Foundation
數據管理:
Core Data
SQLite
圖形和動畫:
Core Animation
OpenGL ES
Quartz 2D
網絡:
Bonjour
WebKit
BSD
Sockets
用戶應用:
Address Book
Core Location
Map Kit
Store Kit
23.自動釋放池是什麼,如何工做
答案：當您向一個對象發送一個autorelease 消息時，Cocoa就會將該對象 的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以 自動釋放池定義的做用域內的其它對象能夠向它發送消息。當 程序 執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對 象也就被釋放。 ojc-c 是 經過一種"referring counting"(引用計數)的方式來管理內 存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰 到有copy,retain的時候引用計數都會加一, 每當碰到release和 autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬. 2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西 通常不用你管的. 3. autorelease和release沒什麼區別,只是引用計數減一的時機不 同而已,autorelease會在對象的使用真正結束的時候才作引用計數 減1.
24.readwrite，readonly，assign，retain，copy，nonatomic 屬性的做用
答案： @property是一個屬性訪問聲明，擴號內支持如下幾個屬性： 1，getter=getterName，setter=setterName，設置setter與getter的方法名
2，readwrite,readonly，設置可供訪問級別
3，assign，setter方法直接賦值，不進行任何retain操做，爲了解決原類 型與環循引用問題
4，retain，setter方法對參數進行release舊值再retain新值，全部實現 都是這個順序(CC上有相關資料)
5，copy，setter方法進行Copy操做，與retain處理流程同樣，先舊值 release，再Copy出新的對象，retainCount爲1。這是爲了減小對上下文 的依賴而引入的機制。
6，nonatomic，非原子性訪問，不加同步，多線程併發訪問會提升性能。 注意，若是不加此屬性，則默認是兩個訪問方法都爲原子型事務訪問。鎖 被加到所屬對象實例級。
25.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 。
26.類工廠方法是什麼
答案：類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中，返回 被建立的對象，並 進行自動釋放處理。這些方法的形式是+ (type)className... （其中 className不包括任何前綴）。 工廠方法可能不 僅僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠 爲 初始化過程提供對 象的分配信息。 類工廠方法的 另外一個目的是使類（好比NSWorkspace）提供單件實例。雖 然init...方法 能夠確認一 個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實 例，而後還必須釋放該實例。 工廠 方法則能夠避免爲可能沒有用的對象盲目分配內存。
27.爲何不少內置類如UITableViewController的delegate屬性都是assign而不是 retain的？
答：會引發循環引用。 這裏delegate咱們只是想獲得實現了它delegate方法的對象，而後拿到這個對象的指針就 能夠了， 咱們不指望去改變它或者作別的什麼操做，因此咱們只要用assign拿到它的指針就能夠了。 而 用retain的話，計數器加1。咱們有可能在別的地方指望釋放掉delegate這個對象， 而後經過一些判斷好比說它是否已經被釋放，作一些操做。可是 實際上它retainCount還 是1，沒有被釋放掉，要在UITableViewController的dealloc裏面才被釋放掉（這裏我只是 舉個 例子，通常retain的對象都是在dealloc裏被釋放）。這裏就會形成一些問題出現。 而若是你肯定不會有衝突的問題出現的話，或者你也但願用到delegate的這個對象，直到 你不用它爲止，那麼用retain也何嘗不可，只是須要最後release一次。
28.
1.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].
29.如下爲Windows NT下的32位C++程序，請計算sizeof的值
void Func ( char str[100] )
{
sizeof( str ) = ?
}
void *p = malloc( 100 );
sizeof ( p ) = ?
答：這題很常見了,Func ( char str[100] )函數中數組名做爲函數形參時，在函數體內，數組名失去了自己的內涵，僅僅只是一個指針；在失去其內涵的同時，它還失去了其常量特性，能夠做自增、自減等操做，能夠被修改。Windows NT 32位平臺下，指針的長度（佔用內存的大小）爲4字節，故sizeof( str ) 、sizeof ( p ) 都爲4。
30.仍是考指針,不過我對cocoa的代碼仍是不太熟悉
大概是這樣的
- （void）*getNSString(const NSString * inputString)
{
inputString = @"This is a main test\n";
return ;
}
-main(void)
{
NSString *a=@"Main";
NSString *aString = [NSString stringWithString:@"%@",getNSString(a)];
NSLog(@"%@\n", aString);
}
答：最後問輸出的字符串:NULL,output在函數返回後，內存已經被釋放。
31.用預處理指令#define聲明一個常數，用以代表1年中有多少秒（忽略閏年問題）
答：#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在這想看到幾件事情：
#define 語法的基本知識（例如：不能以分號結束，括號的使用，等等）
懂得預處理器將爲你計算常數表達式的值，所以，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。
意識到這個表達式將使一個16位機的整型數溢出-所以要用到長整型符號L,告訴編譯器這個常數是的長整型數。
若是你在你的表達式中用到UL（表示無符號長整型），那麼你有了一個好的起點。記住，第一印象很重要。
32.寫一個"標準"宏MIN ，這個宏輸入兩個參數並返回較小的一個。
答：#define MIN(A,B) （（A） <= (B) ? (A) : (B))
這個測試是爲下面的目的而設的：
標識#define在宏中應用的基本知識。這是很重要的，由於直到嵌入(inline)操做符變爲標準C的一部分，宏是方便產生嵌入代碼的惟一方
法，對於嵌入式系統來講，爲了能達到要求的性能，嵌入代碼常常是必須的方法。
三重條件操做符的知識。這個操做符存在C語言中的緣由是它使得編譯器能產生比 if-then-else 更優化的代碼，瞭解這個用法是很重要的。 懂得在宏中當心地把參數用括號括起來 我也用這個問題開始討論宏的反作用，例如：當你寫下面的代碼時會發生什麼事？ least = MIN(*p++, b);
結果是：
((*p++) <= (b) ? (*p++) : (*p++))
這個表達式會產生反作用，指針p會做三次++自增操做。
33.寫一個委託的interface
答：
@protocol MyDelegate;
@interface MyClass: NSObject
{
id <MyDelegate> delegate;
}
// 委託方法
@protocol MyDelegate
- (void)didJobs:(NSArray *)args;
@end
34.寫一個NSString類的實現
答：
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id) stringWithCString: (const char*)nullTerminatedCString
encoding: (NSStringEncoding)encoding
{
NSString *obj;
obj = [self allocWithZone: NSDefaultMallocZone()];
obj = [obj initWithCString: nullTerminatedCString encoding: encoding];
return AUTORELEASE(obj);
}
35.obj-c有多重繼承麼?不是的話有什麼替代方法?
答：
cocoa 中全部的類都是NSObject 的子類
多繼承在這裏是用protocol 委託代理來實現的
你不用去考慮繁瑣的多繼承 ,虛基類的概念.
ood的多態特性在 obj-c 中經過委託來實現.
36.obj-c有私有方法麼?私有變量呢
答：
objective-c - 類裏面的方法只有兩種, 靜態方法和實例方法. 這彷佛就不是完整的面向對象了,按照OO的原則就是一個對象只暴露有用的東西. 若是沒有了私有方法的話, 對於一些小範圍的代碼重用就不那麼順手了. 在類裏面聲名一個私有方法
@interface Controller : NSObject { NSString *something; }
+ (void)thisIsAStaticMethod;
- (void)thisIsAnInstanceMethod;
@end
@interface Controller (private) -
(void)thisIsAPrivateMethod;
@end
@private能夠用來修飾私有變量
在Objective‐C中，全部實例變量默認都是私有的，全部實例方法默認都是公有的
37.關鍵字const有什麼含意？修飾類呢?static的做用,用於類呢?還有extern c的做用
const意味着"只讀"，下面的聲明都是什麼意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
答：
前兩個的做用是同樣，a是一個常整型數。第三個意味着a是一個指向常整型數的指針（也就是，整型數是不可修改的，但指針能夠）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是能夠修改的，但指針是不可修改的）。最後一個意味着a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。
結論：
關鍵字const的做用是爲給讀你代碼的人傳達很是有用的信息，實際上，聲明一個參數爲常量是爲了告訴了用戶這個參數的應用目的。若是 你曾花不少時間清理其它人留下的垃圾，你就會很快學會感謝這點多餘的信息。（固然，懂得用const的程序員不多會留下的垃圾讓別人來清 理的。） 經過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。合理地使用關鍵字const能夠使編譯器很天然地保護那些不但願被改變的參數，防止其被無心的代碼修改。簡而言之，這樣能夠減小bug的出現。
（1）欲阻止一個變量被改變，能夠使用 const 關鍵字。在定義該 const 變量時，一般須要對它進行初
始化，由於之後就沒有機會再去改變它了；
（2）對指針來講，能夠指定指針自己爲 const，也能夠指定指針所指的數據爲 const，或兩者同時指
定爲 const；
（3）在一個函數聲明中，const 能夠修飾形參，代表它是一個輸入參數，在函數內部不能改變其值；
（4）對於類的成員函數，若指定其爲 const 類型，則代表其是一個常函數，不能修改類的成員變量；
（5）對於類的成員函數，有時候必須指定其返回值爲 const 類型，以使得其返回值不爲「左值」。
38.關鍵字volatile有什麼含意?並給出三個不一樣的例子。
一個定義爲volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到
這個變量時必須每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子：
並行設備的硬件寄存器（如：狀態寄存器） 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables) 多線程應用中被幾個任務共享的變量
一個參數既能夠是const還能夠是volatile嗎？解釋爲何。
一個指針能夠是volatile 嗎？解釋爲何。
下面是答案：
是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。
是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。
39.static 關鍵字的做用：
（1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次，
所以其值在下次調用時仍維持上次的值；
（2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問；
（3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明
它的模塊內；
（4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝；
（5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。
40.extern "C" 的做用
（1）被 extern "C"限定的函數或變量是 extern 類型的；
extern 是 C/C++語言中代表函數和全局變量做用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，
其聲明的函數和變量能夠在本模塊或其它模塊中使用。
（2）被 extern "C"修飾的變量和函數是按照 C 語言方式編譯和鏈接的；
41.extern "C"的慣用法
（1）在 C++中引用 C 語言中的函數和變量，在包含 C 語言頭文件（假設爲 cExample.h）時，需進行下列處理：
extern "C"
{
#include "cExample.h"
}
而在 C 語言的頭文件中，對其外部函數只能指定爲 extern 類型，C 語言中不支持 extern "C"聲明， 在.c 文件中包含了 extern "C"時會出現編譯語法錯誤。
（2）在 C 中引用 C++語言中的函數和變量時，C++的頭文件需添加 extern "C"，可是在 C 語言中不 能直接引用聲明瞭 extern "C"的該頭文件，應該僅將 C 文件中將 C++中定義的 extern "C"函數聲明爲 extern 類型。
42.爲何標準頭文件都有相似如下的結構？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
顯然，頭文件中的編譯宏「#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif」 的做用
是防止該頭文件被重複引用。
43.#import跟#include的區別,@class呢?
@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import
而#import比起#include的好處就是不會引發交叉編譯
44.MVC模式的理解
MVC設計模式考慮三種對象：模型對象、視圖對象、和控制器對象。模型對象表明特別的知識和專業技能，它們負責保有應用程序的數據和定義操做數據的邏輯。視圖對象知道如何顯示應用程序的模型數據，並且可能容許用戶對其進行編輯。控制器對象是應用程序的視圖對象和模型對象之間的協調者。
45.線程與進程的區別和聯繫?
進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。
程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。
46.列舉幾種進程的同步機制，並比較其優缺點。
答案： 原子操做 信號量機制 自旋鎖 管程，會合，分佈式系統
進程之間通訊的途徑
答案：共享存儲系統消息傳遞系統管道：以文件系統爲基礎
進程死鎖的緣由
答案：資源競爭及進程推動順序非法
死鎖的4個必要條件
答案：互斥、請求保持、不可剝奪、環路
死鎖的處理
答案：鴕鳥策略、預防策略、避免策略、檢測與解除死鎖
47.堆和棧的區別
答案：管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。
申請大小：
棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。所以，能從棧得到的空間較小。
堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。
碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出
分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。
分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。
48.什麼是鍵-值,鍵路徑是什麼
答案：模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。
鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的
性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型
實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相
關對象的特定屬性。
For example, the key path address.streetwould get the value of the address property from the receiving
object, and then determine the street property relative to the address object.
49.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.
50.目標-動做機制
答案：
目標是動做消息的接收者。一個控件，或者更爲常見的是它的單元，以插座變量（參見"插座變量"部分）
的形式保有其動做消息的目標。
動做是控件發送給目標的消息，或者從目標的角度看，它是目標爲了響應動做而實現的方法。
程序須要某些機制來進行事件和指令的翻譯。這個機制就是目標-動做機制。
51.cocoa touch框架
答案：
iPhone OS 應用程序的基礎 Cocoa Touch 框架重用了許多 Mac 系統的成熟模式，可是它更多地專一於觸摸的接口和優化。UIKit 爲您提供了在 iPhone OS 上實現圖形，事件驅動程序的基本工具，其創建在和 Mac OS X 中同樣的 Foundation 框架上，包括文件處理，網絡，字符串操做等。
Cocoa Touch 具備和 iPhone 用戶接口一致的特殊設計。有了 UIKit，您能夠使用 iPhone OS 上的獨特的圖形接口控件，按鈕，以及全屏視圖的功能，您還能夠使用加速儀和多點觸摸手勢來控制您的應用。
各色俱全的框架 除了 UIKit 外，Cocoa Touch 包含了建立世界一流 iPhone 應用程序須要的全部框架，從三維圖形，到專業音效，甚至提供設備訪問 API 以控制攝像頭，或經過 GPS 獲知當前位置。Cocoa Touch 既包含只須要幾行代碼就能夠完成所有任務的強大的 Objective-C 框架，也在須要時提供基礎的 C 語言 API 來直接訪問系統。這些框架包括：
Core Animation
經過 Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。
Core Audio
Core Audio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。
Core Data
提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用或大或小的數據模型。
功能列表：框架分類
下面是 Cocoa Touch 中一小部分可用的框架：
音頻和視頻
Core Audio
OpenAL
Media Library
AV Foundation
數據管理
Core Data
SQLite
圖形和動畫
Core Animation
OpenGL ES
Quartz 2D
網絡
Bonjour
WebKit
BSD
Sockets
用戶應用
Address Book
Core Location
Map Kit
Store Kit
52.objc的內存管理
答案： 若是您經過分配和初始化（好比[[MyClass alloc] init]）的方式來建立對象，您就擁 有這個對象，須要負責該對象的釋放。這個規則在使用NSObject的便利方法new 時也一樣適用。 若是您拷貝一個對象，您也擁有拷貝獲得的對象，須要負責該對象的釋放。 若是您保持一個對象，您就部分擁有這個對象，須要在再也不使用時釋放該對象。 反過來，若是您從其它對象那裏接收到一個對象，則您不擁有該對象，也不該該釋放它（這個規則有少數 的例外，在參考文檔中有顯式的說明）。
53.自動釋放池是什麼,如何工做
答案：
當您向一個對象發送一個autorelease消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。
1. ojc-c 是經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬.
2. NSAutoreleasePool 就是用來作引用計數的管理工做的,這個東西通常不用你管的.
3. autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一.
54.單件實例是什麼
答案：
Foundation 和 Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager 和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配和初始化。單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比 NSWorkspace），就應該產生一個單件實例，而不是多個實例；若是未來某一天可能有多個實例，您能夠使用單件實例機制，而不是工廠方法或函數。
55.動態綁定
答案：
在運行時肯定要調用的方法 。動態綁定將調用方法的肯定也推遲到運行時。在編譯時，方法的調用並不和代碼綁定在一塊兒，只有在消實發送出來以後，才肯定被調用的代碼。經過動態類型和動態綁定技術，您的代碼每次執行均可以獲得不一樣的結果。運行時因子負責肯定消息的接收者和被調用的方法。運行時的消息分發機制爲動態綁定提供支持。當您向一個動態類型肯定了的對象發送消息時，運行環境系統會經過接收者的isa指針定位對象的類，並以此爲起點肯定被調用的方法，方法和消息是動態綁定的。並且，您沒必要在Objective-C 代碼中作任何工做，就能夠自動獲取動態綁定的好處。您在每次發送消息時，特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而透明地發生。
56.obj-c的優缺點
答案：
objc優勢：
1) Cateogies
2) Posing
3) 動態識別
4) 指標計算
5）彈性訊息傳遞
6) 不是一個過分複雜的 C 衍生語言
7) Objective-C 與 C++ 可混合編程
缺點:
1) 不支援命名空間
2) 不支持運算符重載
3） 不支持多重繼承
4） 使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。
57.sprintf,strcpy,memcpy使用上有什麼要注意的地方
答案：
strcpy是一個字符串拷貝的函數，它的函數原型爲strcpy(char *dst, const char *src);
將src開始的一段字符串拷貝到dst開始的內存中去，結束的標誌符號爲'\0'，因爲拷貝的長度不是由咱們本身控制的，因此這個字符串拷貝很容易出錯。具有字符串拷貝功能的函數有memcpy，這是一個內存拷貝函數，它的函數原型爲memcpy(char *dst, const char* src, unsigned int len);
將長度爲len的一段內存，從src拷貝到dst中去，這個函數的長度可控。可是會有內存疊加的問題。
sprintf是格式化函數。將一段數據經過特定的格式，格式化到一個字符串緩衝區中去。sprintf格式化的函數的長度不可控，有可能格式化後的字符串會超出緩衝區的大小，形成溢出。
58. 用變量a給出下面的定義
a) 一個整型數（An integer）
b)一個指向整型數的指針（ A pointer to an integer）
c)一個指向指針的的指針，它指向的指針是指向一個整型數（ A pointer to a pointer to an intege）r
d)一個有10個整型數的數組（ An array of 10 integers）
e) 一個有10個指針的數組，該指針是指向一個整型數的。（An array of 10 pointers to integers）
f) 一個指向有10個整型數數組的指針（ A pointer to an array of 10 integers）
g) 一個指向函數的指針，該函數有一個整型參數並返回一個整型數（A pointer to a function that takes an integer as an argument
and returns an integer）
h)一個有10個指針的數組，該指針指向一個函數，該函數有一個整型參數並返回一個整型數（ An array of ten pointers to functions t
hat take an integer argument and return an integer ）
答案是：
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 functions that take an integer argument and return an integer
59. 線程與進程的區別和聯繫？
答案：
進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。?進程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。
60. 定義屬性時，什麼狀況使用copy，assign，和retain？
答案：assign用於簡單數據類型，如NSInteger,double,bool。retain和copy用於對象。copy用於當a指向一個對象，b也想指向一樣的對象的時候，若是用assign，a若是釋放，再調用b會crash,若是用copy 的方式，a和b各自有本身的內存，就能夠解決這個問題。retain 會使計數器加1，也能夠解決assign的問題。另外：atomic和nonatomic用來決定編譯器生成的getter和setter是否爲原子操做。在多線程環境下，原子操做是必要的，不然有可能引發錯誤的結果。?加了atomic，setter函數會變成下面這樣：
if (property != newValue)
{
[property release];
property = [newValue retain];
｝
61. 對象是在何時被release的？
答案：
引用計數爲0時。
autorelease實際上只是把對release的調用延遲了，對於每個Autorelease，系統只是把該Object放入了當前的Autorelease pool中，當該pool被釋放時，該pool中的全部Object會被調用Release。對於每個Runloop， 系統會隱式建立一個Autorelease pool，這樣全部的release pool會構成一個象CallStack同樣的一個棧式結構，在每個Runloop結束時，當前棧頂的Autorelease pool會被銷燬，這樣這個pool裏的每一個Object（就是autorelease的對象）會被release。那什麼是一個Runloop呢？ 一個UI事件，Timer call， delegate call， 都會是一個新的Runloop。
62. IPhone OS有沒有垃圾回收？
沒有。iPhone開發的時候沒有垃圾回收機制。
63. ViewController 的 loadView, viewDidLoad, viewDidUnload 分別是在何時調用的？
在自定義ViewController的時候這幾個函數裏面應該作什麼工做？
答案：由init、loadView、viewDidLoad、viewDidUnload、dealloc的關係提及。
init方法：在init方法中實例化必要的對象（聽從LazyLoad思想）。init方法中初始化ViewController自己
loadView方法：當view須要被展現而它倒是nil時，viewController會調用該方法。不要直接調用該方法。若是手工維護views，必須重載重寫該方法；若是使用IB維護views，必須不能重載重寫該方法。loadView和IB構建view，你在控制器中實現了loadView方法，那麼你可能會在應用運行的某個時候被內存管理控制調用。 若是設備內存不足的時候， view 控制器會收到didReceiveMemoryWarning的消息。 默認的實現是檢查當前控制器的view是否在使用。 若是它的view不在當前正在使用的view hierarchy裏面，且你的控制器實現了loadView方法，那麼這個view將被release, loadView方法將被再次調用來建立一個新的view。
viewDidLoad方法：viewDidLoad 此方法只有當view從nib文件初始化的時候才被調用。重載重寫該方法以進一步定製view，在iPhone OS 3.0及以後的版本中，還應該重載重寫viewDidUnload來釋放對view的任何索引；viewDidLoad後調用數據Model。
viewDidUnload方法：當系統內存吃緊的時候會調用該方法（注：viewController沒有被dealloc）。內存吃緊時，在iPhone OS 3.0以前didReceiveMemoryWarning是釋放無用內存的惟一方式，可是OS 3.0及之後viewDidUnload方法是更好的方式。在該方法中將全部IBOutlet（不管是property仍是實例變量）置爲nil（系統release view時已經將其release掉了）在該方法中釋放其餘與view有關的對象、其餘在運行時建立（但非系統必須）的對象、在viewDidLoad中被建立的對象、緩存數據等 release對象後，將對象置爲nil（IBOutlet只須要將其置爲nil，系統release view時已經將其release掉了）
通常認爲viewDidUnload是viewDidLoad的鏡像，由於當view被從新請求時，viewDidLoad還會從新被執行viewDidUnload中被release的對象必須是很容易被從新建立的對象（好比在viewDidLoad或其餘方法中建立的對象），不要release用戶數據或其餘很難被從新建立的對象
dealloc方法：viewDidUnload和dealloc方法沒有關聯，dealloc仍是繼續作它該作的事情。
1、ObjC中，與alloc語義相反的方法是dealloc仍是release？與retain語義相反的方法是dealloc仍是release，爲何？須要與alloc配對使用的方法是dealloc仍是release，爲何？
2、在一個對象的方法裏面:
self.name = 「object」;和
name ＝」object」
有什麼不一樣嗎?
3、這段代碼有什麼問題嗎:
@implementation Person
- (void)setAge:(int)newAge {
self.age = newAge;
}
@end
4、什麼是retain count?
5、如下每行代碼執行後，person對象的retain count分別是多少
Person *person = [[Person alloc] init];
[person retain];
[person release];
[person release];
6、爲何不少內置類如UITableViewController的delegate屬性都是assign而不是retain的？
7、定義屬性時，什麼狀況使用copy，assign，和retain
8、autorelease的對象是在何時被release的？
9、這段代碼有什麼問題,如何修改
10、for (int i = 0; i < someLargeNumber; i++) {
NSString *string = @」Abc」;
string = [string lowercaseString];
string = [string stringByAppendingString:@"xyz"];
NSLog(@「%@」, string);
}
11、autorelease和垃圾回收機制(gc)有什麼關係？
12、IPhone OS有沒有垃圾回收（gc）？
13、什麼是Notification？
答：觀察者模式，controller向defaultNotificationCenter添加本身的notification，其餘類註冊這個notification就能夠收到通知，這些類能夠在收到通知時作本身的操做（多觀察者默認隨機順序發通知給觀察者們，並且每一個觀察者都要等當前的某個觀察者的操做作完才能輪到他來操做，能夠用NotificationQueue的方式安排觀察者的反應順序，也能夠在添加觀察者中設定反映時間，取消觀察須要在viewDidUnload 跟dealloc中都要註銷）
14、何時用delegate，何時用Notification？
答：
15、什麼是KVC和KVO？
答：KVC(Key-Value-Coding)內部的實現：一個對象在調用setValue的時候，（1）首先根據方法名找到運行方法的時候所須要的環境參數。（2）他會從本身isa指針結合環境參數，找到具體的方法實現的接口。（3）再直接查找得來的具體的方法實現。KVO（Key-Value-Observing）：當觀察者爲一個對象的屬性進行了註冊，被觀察對象的isa指針被修改的時候，isa指針就會指向一箇中間類，而不是真實的類。因此isa指針其實不須要指向實例對象真實的類。因此咱們的程序最好不要依賴於isa指針。在調用類的方法的時候，最好要明確對象實例的類名。
1.objective-c中是全部對象間的交互是如何實現的?（深圳皆凱科技有限公司筆試題）
2.如何將產品進行多語言發佈？
3.objective-c中是如何實現線程同步的?
4.編寫函數_memmove說明以下：實現C語言庫函數memmove的功能：將一塊緩衝區中的數據移動到另外一塊緩衝區中。可能有重複。
5.什麼叫數據結構？（面試順風快遞iphone開發）
6.編程中，保存數據有哪幾種方式？
7.Sizeof與strlen的區別和聯繫？
8.什麼是抽象類？抽象類有什麼做用？能實例化嗎？
9.線程中有哪些函數？寫出來
10.有沒有寫過自定義的控件
11.調用一個類的靜態方法需不須要release？
12.do-while 與 while-do的區別？
13.寫出幾個死循環？
14.考察對@interface和@property的理解？
15. Iphone開發中控制類有什麼做用？
16. 用Objective-C寫冒泡法．
Object-C有多繼承嗎？沒有的話用什麼代替？
cocoa 中全部的類都是NSObject 的子類 多繼承在這裏是用protocol 委託代理 來實現的 你不用去考慮繁瑣的多繼承 ,虛基類的概念. ood的多態特性 在 obj-c 中經過委託來實現.
Object-C有私有方法嗎？私有變量呢？
objective-c – 類裏面的方法只有兩種, 靜態方法和實例方法. 這彷佛就不是完整的面向對象了,按照OO的原則就是一個對象只暴露有用的東西. 若是沒有了私有方法的話, 對於一些小範圍的代碼重用就不那麼順手了. 在類裏面聲名一個私有方法 @interface Controller : NSObject { NSString *something; } + (void)thisIsAStaticMethod; – (void)thisIsAnInstanceMethod; @end @interface Controller (private) - (void)thisIsAPrivateMethod; @end
@private能夠用來修飾私有變量 在Objective‐C中，全部實例變量默認都是私有的，全部實例方法默認都是公有的
關鍵字const什麼含義
const意味着」只讀」，下面的聲明都是什麼意思？ const int a; int const a; const int *a; int * const a; int const * a const;
前兩個的做用是同樣，a是一個常整型數。第三個意味着a是一個指向常整型數的指針（也就是，整型數是不可修改的，但指針能夠）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是能夠修改的，但指針是不可修改的）。最後一個意味着a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。
結論： •; 關鍵字const的做用是爲給讀你代碼的人傳達很是有用的信息，實際上，聲明一個參數爲常量是爲了告訴了用戶這個參數的應用目的。若是 你曾花不少時間清理其它人留下的垃圾，你就會很快學會感謝這點多餘的信息。（固然，懂得用const的程序員不多會留下的垃圾讓別人來清 理的。） •; 經過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。 •; 合理地使用關鍵字const能夠使編譯器很天然地保護那些不但願被改變的參數，防止其被無心的代碼修改。簡而言之，這樣能夠減小bug的出現。
欲阻止一個變量被改變，能夠使用 const 關鍵字。在定義該 const 變量時，一般須要對它進行初 始化，由於之後就沒有機會再去改變它了； （2）對指針來講，能夠指定指針自己爲 const，也能夠指定指針所指的數據爲 const，或兩者同時指 定爲 const； （3）在一個函數聲明中，const 能夠修飾形參，代表它是一個輸入參數，在函數內部不能改變其值； （4）對於類的成員函數，若指定其爲 const 類型，則代表其是一個常函數，不能修改類的成員變量； （5）對於類的成員函數，有時候必須指定其返回值爲 const 類型，以使得其返回值不爲「左值」。
關鍵字volatile有什麼含義？並給出三個不一樣例子？
一個定義爲volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到 這個變量時必須每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子： • 並行設備的硬件寄存器（如：狀態寄存器） • 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables) • 多線程應用中被幾個任務共享的變量
• 一個參數既能夠是const還能夠是volatile嗎？解釋爲何。 • 一個指針能夠是volatile 嗎？解釋爲何。
下面是答案： • 是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。 • 是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。
static做用？
函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次， 所以其值在下次調用時仍維持上次的值； （2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問； （3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明 它的模塊內； （4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝； （5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。
#import和#include的區別，@class表明什麼？
@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import 而#import比起#include的好處就是不會引發重複包含
線程和進程的區別？
進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。 進程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。
堆和棧的區別？
管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。 申請大小： 棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。所以，能從棧得到的空間較小。 堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。 碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出 分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。 分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。
Object-C的內存管理？
1.當你使用new,alloc和copy方法建立一個對象時,該對象的保留計數器值爲1.當你再也不使用該對象時,你要負責向該對象發送一條release或autorelease消息.這樣,該對象將在使用壽命結束時被銷燬. 2.當你經過任何其餘方法得到一個對象時,則假設該對象的保留計數器值爲1,並且已經被設置爲自動釋放,你不須要執行任何操做來確保該對象被清理.若是你打算在一段時間內擁有該對象,則須要保留它並確保在操做完成時釋放它. 3.若是你保留了某個對象,你須要(最終)釋放或自動釋放該對象.必須保持retain方法和release方法的使用次數相等.
爲何不少內置的類，如TableViewController的delegate的屬性是assign不是retain？
循環引用 全部的引用計數系統，都存在循環應用的問題。例以下面的引用關係： • 對象a建立並引用到了對象b. • 對象b建立並引用到了對象c. • 對象c建立並引用到了對象b. 這時候b和c的引用計數分別是2和1。當a再也不使用b，調用release釋放對b的全部權，由於c還引用了b，因此b的引用計數爲1，b不會被釋放。b不釋放，c的引用計數就是1，c也不會被釋放。今後，b和c永遠留在內存中。 這種狀況，必須打斷循環引用，經過其餘規則來維護引用關係。好比，咱們常見的delegate每每是assign方式的屬性而不是retain方式 的屬性，賦值不會增長引用計數，就是爲了防止delegation兩端產生沒必要要的循環引用。若是一個UITableViewController 對象a經過retain獲取了UITableView對象b的全部權，這個UITableView對象b的delegate又是a， 若是這個delegate是retain方式的，那基本上就沒有機會釋放這兩個對象了。本身在設計使用delegate模式時，也要注意這點。
定義屬性時，什麼狀況使用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) { [property release]; property = [newValue retain]; }
對象是何時被release的？
引用計數爲0時。 autorelease實際上只是把對release的調用延遲了，對於每個Autorelease，系統只是把該Object放入了當前的Autorelease pool中，當該pool被釋放時，該pool中的全部Object會被調用Release。對於每個Runloop， 系統會隱式建立一個Autorelease pool，這樣全部的release pool會構成一個象CallStack同樣的一個棧式結構，在每個Runloop結束時，當前棧頂的Autorelease pool會被銷燬，這樣這個pool裏的每一個Object（就是autorelease的對象）會被release。那什麼是一個Runloop呢？ 一個UI事件，Timer call， delegate call， 都會是一個新的Runloop
iOS有沒有垃圾回收？
Objective-C 2.0也是有垃圾回收機制的，可是隻能在Mac OS X Leopard 10.5 以上的版本使用。
tableView的重用機制？
查看UITableView頭文件，會找到NSMutableArray* visiableCells，和NSMutableDictnery* reusableTableCells兩個結構。visiableCells內保存當前顯示的cells，reusableTableCells保存可重用的cells。
TableView顯示之初，reusableTableCells爲空，那麼tableView dequeueReusableCellWithIdentifier:CellIdentifier返回nil。開始的cell都是經過[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier]來建立，並且cellForRowAtIndexPath只是調用最大顯示cell數的次數。
好比：有100條數據，iPhone一屏最多顯示10個cell。程序最開始顯示TableView的狀況是：
1. 用[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier]建立10次cell，並給cell指定一樣的重用標識(固然，能夠爲不一樣顯示類型的cell指定不一樣的標識)。而且10個cell所有都加入到visiableCells數組，reusableTableCells爲空。
2. 向下拖動tableView，當cell1徹底移出屏幕，而且cell11(它也是alloc出來的，緣由同上)徹底顯示出來的時候。cell11加入到visiableCells，cell1移出visiableCells，cell1加入到reusableTableCells。
3. 接着向下拖動tableView，由於reusableTableCells中已經有值，因此，當須要顯示新的cell，cellForRowAtIndexPath再次被調用的時候，tableView dequeueReusableCellWithIdentifier:CellIdentifier，返回cell1。cell1加入到visiableCells，cell1移出reusableTableCells；cell2移出visiableCells，cell2加入到reusableTableCells。以後再須要顯示的Cell就能夠正常重用了。
ViewController 的loadView、viewDidLoad、viewDidUnload分別是何時調用的，在自定義ViewCointroller時在這幾個函數中應該作什麼工做？
由init、loadView、viewDidLoad、viewDidUnload、dealloc的關係提及 init方法 在init方法中實例化必要的對象（聽從LazyLoad思想） init方法中初始化ViewController自己
loadView方法 當view須要被展現而它倒是nil時，viewController會調用該方法。不要直接調用該方法。 若是手工維護views，必須重載重寫該方法 若是使用IB維護views，必須不能重載重寫該方法
loadView和IB構建view 你在控制器中實現了loadView方法，那麼你可能會在應用運行的某個時候被內存管理控制調用。 若是設備內存不足的時候， view 控制器會收到didReceiveMemoryWarning的消息。 默認的實現是檢查當前控制器的view是否在使用。 若是它的view不在當前正在使用的view hierarchy裏面，且你的控制器實現了loadView方法，那麼這個view將被release, loadView方法將被再次調用來建立一個新的view。
viewDidLoad方法 viewDidLoad 此方法只有當view從nib文件初始化的時候才被調用。 重載重寫該方法以進一步定製view 在iPhone OS 3.0及以後的版本中，還應該重載重寫viewDidUnload來釋放對view的任何索引 viewDidLoad後調用數據Model
viewDidUnload方法 當系統內存吃緊的時候會調用該方法（注：viewController沒有被dealloc） 內存吃緊時，在iPhone OS 3.0以前didReceiveMemoryWarning是釋放無用內存的惟一方式，可是OS 3.0及之後viewDidUnload方法是更好的方式 在該方法中將全部IBOutlet（不管是property仍是實例變量）置爲nil（系統release view時已經將其release掉了）
在該方法中釋放其餘與view有關的對象、其餘在運行時建立（但非系統必須）的對象、在viewDidLoad中被建立的對象、緩存數據等 release對象後，將對象置爲nil（IBOutlet只須要將其置爲nil，系統release view時已經將其release掉了）
通常認爲viewDidUnload是viewDidLoad的鏡像，由於當view被從新請求時，viewDidLoad還會從新被執行
viewDidUnload中被release的對象必須是很容易被從新建立的對象（好比在viewDidLoad或其餘方法中建立的對象），不要release用戶數據或其餘很難被從新建立的對象
dealloc方法 viewDidUnload和dealloc方法沒有關聯，dealloc仍是繼續作它該作的事情
ViewController的didReceiveMemoryWarning是在何時調用的？默認的操做是什麼？
當程序接到內存警告時View Controller將會收到這個消息：didReceiveMemoryWarning
從iOS3.0開始，不須要重載這個函數，把釋放內存的代碼放到viewDidUnload中去。
這個函數的默認實現是:檢查controller是否能夠安全地釋放它的view(這裏加粗的view指的是controller的view屬性)，好比view自己沒有superview而且能夠被很容易地重建（從nib或者loadView函數）。
若是view能夠被釋放，那麼這個函數釋放view並調用viewDidUnload。
你能夠重載這個函數來釋放controller中使用的其餘內存。但要記得調用這個函數的super實現來容許父類（通常是UIVIewController）釋放view。
若是你的ViewController保存着view的子view的引用，那麼，在早期的iOS版本中，你應該在這個函數中來釋放這些引用。而在iOS3.0或更高版本中，你應該在viewDidUnload中釋放這些引用。
列舉Cocoa中常見的集中多線程的實現，並談談多線程安全的幾種解決辦法，通常什麼地方會用到多線程？
NSOperation NSThread @sychonized
怎麼理解MVC，在Cocoa中MVC是怎麼實現的？
MVC設計模式考慮三種對象：模型對象、視圖對象、和控制器對象。模型對象表明特別的知識和專業技能，它們負責保有應用程序的數據和定義操做數據的邏輯。視圖對象知道如何顯示應用程序的模型數據，並且可能容許用戶對其進行編輯。控制器對象是應用程序的視圖對象和模型對象之間的協調者。 ViewCotroller Xib
delegate和notification區別，分別在什麼狀況下使用？
KVC(Key-Value-Coding) KVO（Key-Value-Observing） 理解KVC與KVO（鍵-值-編碼與鍵-值-監看）
當經過KVC調用對象時，好比：[self valueForKey:@」someKey」]時，程序會自動試圖經過幾種不一樣的方式解析這個調用。首先查找對象是否帶有 someKey 這個方法，若是沒找到，會繼續查找對象是否帶有someKey這個實例變量（iVar），若是尚未找到，程序會繼續試圖調用 -(id) valueForUndefinedKey:這個方法。若是這個方法仍是沒有被實現的話，程序會拋出一個NSUndefinedKeyException異常錯誤。
(Key-Value Coding查找方法的時候，不只僅會查找someKey這個方法，還會查找getsomeKey這個方法，前面加一個get，或者_someKey以及_getsomeKey這幾種形式。同時，查找實例變量的時候也會不只僅查找someKey這個變量，也會查找_someKey這個變量是否存在。)
設計valueForUndefinedKey:方法的主要目的是當你使用-(id)valueForKey方法從對象中請求值時，對象可以在錯誤發生前，有最後的機會響應這個請求。
self.跟self什麼區別？
id、nil表明什麼？
id
id和void *並不是徹底同樣。在上面的代碼中，id是指向struct objc_object的一個指針，這個意思基本上是說，id是一個指向任何一個繼承了Object（或者NSObject）類的對象。須要注意的是id是一個指針，因此你在使用id的時候不須要加星號。好比id foo=nil定義了一個nil指針，這個指針指向NSObject的一個任意子類。而id *foo=nil則定義了一個指針，這個指針指向另外一個指針，被指向的這個指針指向NSObject的一個子類。
nil
nil和C語言的NULL相同，在objc/objc.h中定義。nil表示一個Objctive-C對象，這個對象的指針指向空（沒有東西就是空）。
內存管理 Autorelease、retain、copy、assign的set方法和含義？
1，你初始化(alloc/init)的對象，你須要釋放(release)它。例如：
NSMutableArray aArray = [[NSArray alloc] init];
後，須要
[aArray release];
2，你retain或copy的，你須要釋放它。例如：
[aArray retain]
後，須要
[aArray release];
3，被傳遞(assign)的對象，你須要斟酌的retain和release。例如：
obj2 = [[obj1 someMethod] autorelease];
對象2接收對象1的一個自動釋放的值，或傳遞一個基本數據類型(NSInteger，NSString)時： 你或但願將對象2進行retain，以防止它在被使用以前就被自動釋放掉。可是在retain後，必定要在適當的時候進行釋放。
關於索引計數(Reference Counting)的問題
retain值 = 索引計數(Reference Counting)
NSArray對象會retain(retain值加一)任何數組中的對象。當NSArray被卸載(dealloc)的時候，全部數組中的對象會被執行一次釋放(retain值減一)。不只僅是NSArray，任何收集類(Collection Classes)都執行相似操做。例如NSDictionary，甚至UINavigationController。
Alloc/init創建的對象，索引計數爲1。無需將其再次retain。
[NSArray array]和[NSDate date]等「方法」創建一個索引計數爲1的對象，可是也是一個自動釋放對象。因此是本地臨時對象，那麼無所謂了。若是是打算在全Class中使用的變量(iVar)，則必須retain它。
缺省的類方法返回值都被執行了「自動釋放」方法。(*如上中的NSArray)
在類中的卸載方法「dealloc」中，release全部未被平衡的NS對象。(*全部未被autorelease，而retain值爲1的)
類別的做用？
有時咱們須要在一個已經定義好的類中增長一些方法，而不想去重寫該類。好比，當工程已經很大，代碼量比較多，或者類中已經包住不少方法，已經有其餘代碼調用了該類建立對象並使用該類的方法時，能夠使用類別對該類擴充新的方法。
注意：類別只能擴充方法，而不能擴充成員變量。
委託（舉例）
委託代理（degegate），顧名思義，把某個對象要作的事情委託給別的對象去作。那麼別的對象就是這個對象的代理，代替它來打理要作的事。反映到程序中，首先要明確一個對象的委託方是哪一個對象，委託所作的內容是什麼。 委託機制是一種設計模式，在不少語言中都用到的，這只是個通用的思想，網上會有不少關於這方面的介紹。 那麼在蘋果開發過程當中，用到委託的程序實現思想以下，我主要拿如何在視圖之間傳輸信息作個例子。 譬如：在兩個頁面（UIIview視圖對象）實現傳值，用委託（delegate）能夠很好作到！ 方法： 類A @interface A：UIView id transparendValueDelegate; @property(nomatic, retain) id transparendValueDelegate; @end @implemtion A @synthesize transparendValueDelegate -(void)Function { NSString* value = @"hello"; //讓代理對象執行transparendValue動做 [transparendValueDelegate transparendValue: value]; } @end 類B @interface B：UIView NSString* value; @end @implemtion B -(void)transparendValue:(NSString*)fromValue { value = fromValue; NSLog(@"the value is %@ ",value); } @end //下面的設置A代理委託對象爲B //在定義A和B類對象處： A* a = [[A alloc] init]; B* b = [[B alloc] init]; a. transparendValueDelegate = b;//設置對象a代理爲對象b 這樣在視圖A和B之間能夠經過委託來傳值！ 下面這個例子委託有兩類： 一、一個視圖類對象的代理對象爲父視圖，子視圖用代理實現讓父視圖顯示別的子視圖 二、同一父視圖下的一個子視圖爲另外一個子視圖的代理對象，讓另外一個子視圖改變自身背景色爲給定的顏色 ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ 規範格式以下： @protocol TransparendValueDelegate; @interface A：UIView id< TransparendValueDelegate > m_dTransparendValueDelegate; @property(nomatic, retain) id m_dTransparendValueDelegate; @end //代理協議的聲明 @protocol TransparendValueDelegat<NSObject> { -(void)transparendValue:(NSString*)fromValue; }
retainCount？
【轉】iPhone 面試題解答
2011-10-11 21:34
轉載自 492437598
最終編輯 492437598
| 1.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是數組指針，其類型爲 int (*)[5]; a,&a的地址是同樣的，但意思不同
2. 如下爲Windows NT下的32位C++程序，請計算sizeof的值
這題 很常見了,Func ( char str[100] )函數中數組名做爲函數形參時，在函數體內，數組名失去了自己的內涵，僅僅只是一個指針；在失去其內涵的同時，它還失去了其常量特性，能夠做自增、自減等 操做，能夠被修改。Windows NT 32位平臺下，指針的長度（佔用內存的大小）爲4字節，故sizeof( str ) 、sizeof ( p ) 都爲4。
3.仍是考指針,不過我對cocoa的代碼仍是不太熟悉 大概是這樣的 - （void）*getNSString(const NSString * inputString) { is a main test\n"; return ; } -main(void) {
NSString ";
NSString *aString = [NSString stringWithString:@"%@",getNSString(a)];
NSLog(@"%@\n", aString); }
最後問輸出的字符串:NULL,output在 函數返回後，內存已經被釋放。
4.用預處理指令#define聲明一個常數，用以代表1年中有多少秒（忽略閏年問題）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
寫一個"
結果是： + (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding; + (id) stringWithCString: (const char*)nullTerminatedCString obj = [self allocWithZone: NSDefaultMallocZone()]; 7.obj-c有多重繼承麼?不是的話有什麼替代方法?
多繼承在這裏是用protocol 委託代理 來實現的 9.關鍵字const有什麼含意？修飾類呢?static的做 用,用於類呢?還有extern c的做用
const 意味着"只讀"，下面的聲明都是什麼意思？
前兩個的做用是同樣，a是一個常整型數。第三個意味着a是一個指向常整型數的指 針（也就是，整型數是不可修改的，但指針能夠）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是能夠修改的，但指針是不可修改 的）。最後一個意味着a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。
結論： ?; 關鍵字const的做用是爲給讀你代碼的人傳達很是有用的信息，實際上，聲明一個參數爲常量是爲了告訴了用戶這個參數的應用目的。若是 （1）欲阻止一個變量被改變，能夠使用 const 關鍵字。在定義該 const 變量時，一般須要對它進行初 關鍵字volatile有什麼含意?並給出三個不一樣的例子。
一個定義爲 volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到 ?; 並行設備的硬件寄存器（如：狀態寄存器）
?; 一個參數既能夠是const還能夠是volatile嗎？解釋爲何。
static 關鍵字的做用：
（1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次， extern "C" 的做用
（1）被 extern "C"限定的函數或變量是 extern 類型的； extern 是 C/C++語言中代表函數和全局變量做用範圍（可見性）的關鍵字，該關鍵字告訴編譯器， （2）被 extern "C"修飾的變量和函數是按照 C 語言方式編譯和鏈接的；
extern "C"的慣用法 （1）在 C++中引用 C 語言中的函數和變量，在包含 C 語言頭文件（假設爲 cExample.h）時，需進 （2）在 C 中引用 C++語言中的函數和變量時，C++的頭文件需添加 extern "C"，可是在 C 語言中不 10.爲何標準頭文件都有相似如下的結構？ 顯然，頭文件中的編譯宏「#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif」 的做用
11.#import跟#include的區別,@class呢?
@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文 件中仍是須要使用#import 而#import比起#include的好處就是不會引發交叉編譯 12.MVC模式的理解 MVC設計模式考慮三種對象：模型對象、視圖對象、和控制器對象。模型對象表明 特別的知識和專業技能，它們負責保有應用程序的數據和定義操做數據的邏輯。視圖對象知道如何顯示應用程序的模型數據，並且可能容許用戶對其進行編輯。控制 器對象是應用程序的視圖對象和模型對象之間的協調者。 13.線程與進程的區別和聯繫?
進程和線程都是由操做系統所體會的程序運行的基本 單元，系統利用該基本單元實現系統對應用的併發性。 程和線程的主要差異在於它們是不一樣的操做系統資源 管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變 量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一 些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。
14.列舉幾種進程的同步機制，並比較其優缺點。 答案： 原子操做 信號量機制 自旋鎖 管程，會合，分佈式系統 答案：共享存儲系統消息傳遞系統管道：以文件系統爲基礎 答案：資源競爭及進程推動順序非法 答案：互斥、請求保持、不可剝奪、環路 答案：鴕鳥策略、預防策略、避免策略、檢測與解除死鎖
15.堆和棧的區別
管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。 申請大小： 碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個 問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出 分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由 alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。 分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的 效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。 。 19.cocoa touch框架
iPhone OS 應用程序的基礎 Cocoa Touch 框架重用了許多 Mac 系統的成熟模式，可是它更多地專一於觸摸的接口和優化。UIKit 爲您提供了在 iPhone OS 上實現圖形，事件驅動程序的基本工具，其創建在和 Mac OS X 中同樣的 Foundation 框架上，包括文件處理，網絡，字符串操做等。
Cocoa Touch 具備和 iPhone 用戶接口一致的特殊設計。有了 UIKit，您能夠使用 iPhone OS 上的獨特的圖形接口控件，按鈕，以及全屏視圖的功能，您還能夠使用加速儀和多點觸摸手勢來控制您的應用。
各色俱全的框架 除了 UIKit 外，Cocoa Touch 包含了建立世界一流 iPhone 應用程序須要的全部框架，從三維圖形，到專業音效，甚至提供設備訪問 API 以控制攝像頭，或經過 GPS 獲知當前位置。Cocoa Touch 既包含只須要幾行代碼就能夠完成所有任務的強大的 Objective-C 框架，也在須要時提供基礎的 C 語言 API 來直接訪問系統。這些框架包括： Core Animation 經過 Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。 Core Audio Core Audio 是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。 Core Data 提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用 或大或小的數據模型。 功能列表：框架分類 下面是 Cocoa Touch 中一小部分可用的框架： 音頻和視頻
圖形和動畫
用戶應用
20.objc的內存管理
? 若是您經過分配和初始化（好比[[MyClass alloc] init]）的方式來建立對象，您就擁 21.自動釋放池是什麼,如何工做 當您向一個對象發送一個autorelease消息時，Cocoa就會將該對 象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置 時，自動釋放池就會被釋放，池中的全部對象也就被釋放。 1. ojc-c 是經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬. 22.類工廠方法是什麼 類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中， 返回被建立的對象，並 工廠方法可能不只僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠 爲初始化過程提供對 類工廠方法的另外一個目的是使類（好比NSWorkspace）提供單件實例。雖 然init...方法能夠確認一
23.單件實例是什麼 Foundation 和 Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager 和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配 和初始化。 單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比
24.動態綁定 —在運行時肯定要調用的方法
動態綁定將調用方法的肯定也推遲到運行時。在編譯時，方法的調用並不和代碼綁定 在一塊兒，只有在消實發送出來以後，才肯定被調用的代碼。經過動態類型和動態綁定技術，您的代碼每次執行均可以獲得不一樣的結果。運行時因子負責肯定消息的接 收者和被調用的方法。 運行時的消息分發機制爲動態綁定提供支持。當您向一個動態類型肯定了的對象發送消息時，運行環境系統會經過接收者的isa指針定位對象的類，並以此爲起點 肯定被調用的方法，方法和消息是動態綁定的。並且，您沒必要在Objective-C 代碼中作任何工做，就能夠自動獲取動態綁定的好處。您在每次發送消息時，
25.obj-c的優缺點 objc優勢： 3） 不支持多重繼承 4） 使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。
26.sprintf,strcpy,memcpy使用上有什 麼要注意的地方
strcpy是一個字符串拷貝的函數，它的函數原型爲strcpy(char *dst, const char *src); 將src開始的一段字符串拷貝到dst開始的內存中去，結束的標誌符號爲 '\0'，因爲拷貝的長度不是由咱們本身控制的，因此這個字符串拷貝很容易出錯。具有字符串拷貝功能的函數有memcpy，這是一個內存拷貝函數，它的函 數原型爲memcpy(char *dst, const char* src, unsigned int len); 將長度爲len的一段內存，從src拷貝到dst中去，這個函數的長度可控。但 是會有內存疊加的問題。 sprintf是格式化函數。將一段數據經過特定的格式，格式化到一個字符串緩 衝區中去。sprintf格式化的函數的長度不可控，有可能格式化後的字符串會超出緩衝區的大小，形成溢出。 27. 用變量a給出下面的定義 a) 一個整型數（An integer） 28.readwrite，readonly，assign，retain，copy，nonatomic 屬性的做用 @property是 一個屬性訪問聲明，擴號內支持如下幾個屬性：
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
1Objective－C內部的實現 2CALayer和View的關係 3 http協議，tcp/ip 4 UITableView的那些元素是能夠自定義的？ 5 c語言的，定義變量，好比int，在什麼狀況下，其最大值是不一樣的 6 比較32位平臺和64位平臺不一樣 7 iphone app爲何會被打回來，如何避免?? 8 爲啥離開團隊？
1.針對第一個問題，能夠看看下面的教程 Object c研究的比較深刻的教程 第6章寫的尤爲好
KVO/KVC 實現機理分析 http://archive.cnblogs.com/a/1886332/
2.CALayer和View的關係 一個UIView包含CALayer樹，CALayer是一個數據模型，包含了一些用於顯示的對象，但自己不用於顯示。 CALayer至關於photoshop的一個層，不少動畫能夠經過設置CALayer來實現。聽說有人用CALayer顯示圖片來播放視頻。 Core animation應該是用CAlayer來實現各類動畫。 這裏有篇博文，介紹的還能夠http://www.cnblogs.com/uyoug321/archive/2011/01/22.html 這套題目來自cocoachina的yoyokko版主大大招人時候的題目,論壇各路大神都以爲偏難。本身看了一下，發現不少是本身知道，但又說不上來的感受。因此以爲有必要梳理完善一下，題不少，反正寫到哪算哪吧！另外，由於我不是C/C++ 或寫 mac 「發家」 因此仍是有解答不上來的，可是關於IOS方面，必定儘可能解答，若是回答得有不盡入人意的地方，歡迎高手糾正。 下面先看看題目: 1.Object－c的類能夠多重繼承麼？能夠實現多個接口麼？Category是什麼？重寫一個類的方式用繼承好仍是分類好？爲何？ 2.#import 跟#include 又什麼區別 ＃import<> 跟 #import""又什麼區別？ 3.類變量的@protected ,@private,@public,@package聲明各有什麼含義？ 4.id 聲明的對象有什麼特性？ 5.MVC是什麼？有什麼特性？爲何在iPhone上被普遍運用？ 6.對於語句NSString* testObject = [[NSData alloc] init];testObject 在編譯時和運行時分別時什麼類型的對象？ 7.什麼是安全釋放？ 8.爲何有些4.0獨有的objective－c 函數在3.1上運行時會報錯.而4.0獨有的類在3.1上分配內存時不會報錯？分配的結果是什麼？ 9.爲何4.0獨有的c函數在3.1的機器上運行不會報錯（在沒有調用的狀況下？）而4.0獨有的類名在3.1的機器上一運行就報錯？ 10.異常exception 怎麼捕獲？不一樣的CPU結構上開銷怎樣？C中又什麼相似的方法？ 11.property中屬性retain,copy,assgin的含義分別是什麼？有什麼區別？將其轉換成get／set方法怎麼作？有什麼注意事項？ 12.委託是什麼？委託的property聲明用什麼屬性？爲何？ 13.淺拷貝和深拷貝區別是什麼？... 14.Cocoa中與虛基類的概念麼？怎麼簡潔的實現？ 15.自動釋放池跟GC有什麼區別？iPhone上有GC麼？［pool release］ 和［pool drain］有什麼區別？ 16. for(int index = 0; index < 20; index ++){ NSString *tempStr = @」tempStr」; NSLog(tempStr); NSNumber *tempNumber = [NSNumber numberWithInt:2]; NSLog(tempNumber); } 這段代碼有什麼問題.？會不會形成內存泄露（多線程）？在內存緊張的設備上作大循環時自動釋放池是寫在循環內好仍是循環外好？爲何？ 17.內存管理的幾條原則時什麼？按照默認法則.那些關鍵字生成的對象須要手動釋放？在和property結合的時候怎樣有效的避免內存泄露？ 18.在一個對象釋放前.若是他被加到了notificationCenter 中.不在notificationcenter中remove這個對象可能會出現什麼問題？ 19.怎樣實現一個 singleton的類.給出思路。 20.什麼是序列化或者Acrchiving,能夠用來作什麼,怎樣與copy結合,原理是什麼?. 21.線程是什麼？ 有哪些注意事項.? 22.在iphone上有兩件事情要作,請問是在一個線程裏按順序作效率高仍是兩個線程裏作效率高？爲何？ 23.runloop是什麼？在主線程中的某個函數裏調用了異步函數，怎麼樣block當前線程,且還能響應當前線程的timer事件，touch事件等. 24.ios平臺怎麼作數據的持久化?coredata和sqlite有無必然聯繫？coredata是一個關係型數據庫嗎？ 25.闡述一個nil對象從interface bulider產生，到載入程序運行空間，最後被釋放時所經歷的生命週期. 26.notification是同步仍是異步? kvo是同步仍是異步？notification是全進程空間的通知嗎？kvo呢？ 27.kvc是什麼?kvo是什麼?有什麼特性？ 28.響應者鏈是什麼？ 29.unix上進程怎麼通訊？ 30.timer的間隔週期準嗎？爲何？怎樣實現一個精準的timer? 31.UIscrollVew用到了什麼設計模式？還能再foundation庫中找到相似的嗎？ 32若是要開發一個相似eclipse的軟件，支持插件結構。且開放給第三方開發。你會怎樣去設計它？（大概思路）
iOS開發工程師筆試題（請在30分鐘內作完） 1. 用預處理指令#define聲明一個常數，用以代表1年中有多少秒（忽略閏年問題）： #define SECONDS_PER_YEAR (60 * 60 * 24 * 365ul) 1) #define 語法的基本知識（例如：不能以分號結束，括號的使用，等等） 2)懂得預處理器將爲你計算常數表達式的值，所以，直接寫出你是如何計算一年中有多少 秒而不是計算出實際的值，是更清晰而沒有代價的。 3) 意識到這個表達式將使一個16位機的整型數溢出-所以要用到長整型符號L,告訴編譯器這個常數是的長整型數。 4) 若是你在你的表達式中用到UL（表示無符號長整型），那麼你有了一個好的起點。 2. Objective-C有多重繼承麼？不是的話有什麼替代方法？ Dfad cocoa 中全部的類都是NSObject 的子類 多繼承在這裏是用protocol 委託代理 來實現的 你不用去考慮繁瑣的多繼承 ,虛基類的概念. ood的多態特性 在 obj-c 中經過委託來實現. 3. Objective-C有私有方法麼？私有變量呢？ objective-c – 類裏面的方法只有兩種, 靜態方法和實例方法. 這彷佛就不是完整的面向對象了,按照OO的原則就是一個對象只暴露有用的東西. 若是沒有了私有方法的話, 對於一些小範圍的代碼重用就不那麼順手了. 在類裏面聲名一個私有方法 @interface Controller : NSObject { NSString *something; } + (void)thisIsAStaticMethod; – (void)thisIsAnInstanceMethod; @end @interface Controller (private) - (void)thisIsAPrivateMethod; @end @private能夠用來修飾私有變量 在Objective‐C中，全部實例變量默認都是私有的，全部實例方法默認都是公有的 4. 關鍵字const有什麼含意？ Asdfds const意味着」只讀」，下面的聲明都是什麼意思？ const int a; int const a; const int *a; int * const a; int const * a const; 前兩個的做用是同樣，a是一個常整型數。第三個意味着a是一個指向常整型數的指針（也就是，整型數是不可修改的，但指針能夠）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是能夠修改的，但指針是不可修改的）。最後一個意味着a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。 結論： •; 關鍵字const的做用是爲給讀你代碼的人傳達很是有用的信息，實際上，聲明一個參數爲常量是爲了告訴了用戶這個參數的應用目的。若是 你曾花不少時間清理其它人留下的垃圾，你就會很快學會感謝這點多餘的信息。（固然，懂得用const的程序員不多會留下的垃圾讓別人來清 理的。） •; 經過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。 •; 合理地使用關鍵字const能夠使編譯器很天然地保護那些不但願被改變的參數，防止其被無心的代碼修改。簡而言之，這樣能夠減小bug的出現。 （1）欲阻止一個變量被改變，能夠使用 const 關鍵字。在定義該 const 變量時，一般須要對它進行初 始化，由於之後就沒有機會再去改變它了； （2）對指針來講，能夠指定指針自己爲 const，也能夠指定指針所指的數據爲 const，或兩者同時指 定爲 const； （3）在一個函數聲明中，const 能夠修飾形參，代表它是一個輸入參數，在函數內部不能改變其值； （4）對於類的成員函數，若指定其爲 const 類型，則代表其是一個常函數，不能修改類的成員變量； （5）對於類的成員函數，有時候必須指定其返回值爲 const 類型，以使得其返回值不爲「左值」。 5. 關鍵字volatile有什麼含意?並給出三個不一樣的例子： 一個定義爲volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到 這個變量時必須每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子： • 並行設備的硬件寄存器（如：狀態寄存器） • 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables) • 多線程應用中被幾個任務共享的變量 • 一個參數既能夠是const還能夠是volatile嗎？解釋爲何。 • 一個指針能夠是volatile 嗎？解釋爲何。 下面是答案： • 是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。 • 是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。 6. 簡單闡述static 關鍵字的做用： （1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次， 所以其值在下次調用時仍維持上次的值； （2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問； （3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明 它的模塊內； （4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝； （5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。 8. 線程與進程的區別和聯繫？ 進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。 進程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。 9. 簡單闡述堆和棧的區別： asdfad 管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。 申請大小： 棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。所以，能從棧得到的空間較小。 堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。 碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出 分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比局部變量的分配。動態分配由alloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需咱們手工實現。 分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的。 10. 簡單闡述一下Objective-C內存管理： 1.當你使用new,alloc和copy方法建立一個對象時,該對象的保留計數器值爲1.當你再也不使用該對象時,你要負責向該對象發送一條release或autorelease消息.這樣,該對象將在使用壽命結束時被銷燬. 2.當你經過任何其餘方法得到一個對象時,則假設該對象的保留計數器值爲1,並且已經被設置爲自動釋放,你不須要執行任何操做來確保該對象被清理.若是你打算在一段時間內擁有該對象,則須要保留它並確保在操做完成時釋放它. 3.若是你保留了某個對象,你須要(最終)釋放或自動釋放該對象.必須保持retain方法和release方法的使用次數相等. 11. 爲何不少內置類如UITableViewController的delegate屬性都是assign而不是retain的？ 會引發循環引用。 12. 定義屬性時，什麼狀況使用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) { [property release]; property = [newValue retain]; } 13. 對象是在何時被release的？ 引用計數爲0時。 autorelease實際上只是把對release的調用延遲了，對於每個Autorelease，系統只是把該Object放入了當前的Autorelease pool中，當該pool被釋放時，該pool中的全部Object會被調用Release。對於每個Runloop， 系統會隱式建立一個Autorelease pool，這樣全部的release pool會構成一個象CallStack同樣的一個棧式結構，在每個Runloop結束時，當前棧頂的Autorelease pool會被銷燬，這樣這個pool裏的每一個Object（就是autorelease的對象）會被release。那什麼是一個Runloop呢？ 一個UI事件，Timer call， delegate call， 都會是一個新的Runloop。 14. IPhone OS有沒有垃圾回收？ Objective-C 2.0也是有垃圾回收機制的，可是隻能在Mac OS X Leopard 10.5 以上的版本使用。 15. ViewController 的 loadView, viewDidLoad, viewDidUnload 分別是在何時調用的？在自定義ViewController的時候這幾個函數裏面應該作什麼工做？ 由init、loadView、viewDidLoad、viewDidUnload、dealloc的關係提及 init方法 在init方法中實例化必要的對象（聽從LazyLoad思想） init方法中初始化ViewController自己 loadView方法 當view須要被展現而它倒是nil時，viewController會調用該方法。不要直接調用該方法。 若是手工維護views，必須重載重寫該方法 若是使用IB維護views，必須不能重載重寫該方法 loadView和IB構建view 你在控制器中實現了loadView方法，那麼你可能會在應用運行的某個時候被內存管理控制調用。 若是設備內存不足的時候， view 控制器會收到didReceiveMemoryWarning的消息。 默認的實現是檢查當前控制器的view是否在使用。 若是它的view不在當前正在使用的view hierarchy裏面，且你的控制器實現了loadView方法，那麼這個view將被release, loadView方法將被再次調用來建立一個新的view。 viewDidLoad方法 viewDidLoad 此方法只有當view從nib文件初始化的時候才被調用。 重載重寫該方法以進一步定製view 在iPhone OS 3.0及以後的版本中，還應該重載重寫viewDidUnload來釋放對view的任何索引 viewDidLoad後調用數據Model viewDidUnload方法 當系統內存吃緊的時候會調用該方法（注：viewController沒有被dealloc） 內存吃緊時，在iPhone OS 3.0以前didReceiveMemoryWarning是釋放無用內存的惟一方式，可是OS 3.0及之後viewDidUnload方法是更好的方式 在該方法中將全部IBOutlet（不管是property仍是實例變量）置爲nil（系統release view時已經將其release掉了） 在該方法中釋放其餘與view有關的對象、其餘在運行時建立（但非系統必須）的對象、在viewDidLoad中被建立的對象、緩存數據等 release對象後，將對象置爲nil（IBOutlet只須要將其置爲nil，系統release view時已經將其release掉了） 通常認爲viewDidUnload是viewDidLoad的鏡像，由於當view被從新請求時，viewDidLoad還會從新被執行 viewDidUnload中被release的對象必須是很容易被從新建立的對象（好比在viewDidLoad或其餘方法中建立的對象），不要release用戶數據或其餘很難被從新建立的對象 dealloc方法 viewDidUnload和dealloc方法沒有關聯，dealloc仍是繼續作它該作的事情 16. ViewController 的 didReceiveMemoryWarning 是在何時被調用的？默認的操做是什麼? 17. 列舉Cocoa中經常使用的幾種多線程實現，並談談多線程安全問題的幾種解決方案，什麼地方會用到多線程 NSOperation NSThread @sychonized 18. 你是怎麼理解MVC的，在Cocoa中MVC是怎麼實現的？ Adsfasd MVC設計模式考慮三種對象：模型對象、視圖對象、和控制器對象。模型對象表明特別的知識和專業技能，它們負責保有應用程序的數據和定義操做數據的邏輯。視圖對象知道如何顯示應用程序的模型數據，並且可能容許用戶對其進行編輯。控制器對象是應用程序的視圖對象和模型對象之間的協調者。 ViewCotroller Xib 19. KVC,KVO Ewe KVC(Key-Value-Coding) KVO（Key-Value-Observing） 理解KVC與KVO（鍵-值-編碼與鍵-值-監看） http://www.cocoachina.com/macdev/cocoa/2009/0611/221.html k－v－o 掃盲 http://www.cnblogs.com/scorpiozj/archive/2011/03/14/1983643.html 當經過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方法從對象中請求值時，對象可以在錯誤發生前，有最後的機會響應這個請求。 |
ios開發工程師常見面試題彙總
1.Object－c的類能夠多重繼承麼？能夠實現多個接口麼？Category是什麼？重寫一個類的方式用繼承好仍是分類好？爲何？
2.#import 跟#include 又什麼區別，@class呢； ＃import<> 跟 #import」"又什麼區別？
3.屬性readwrite，readonly，assign，retain，copy，nonatomic 各是什麼做用，在那種狀況下用？
4.id 聲明的對象有什麼特性？
5.MVC是什麼？有什麼特性？爲何在iPhone上被普遍運用？
6.對於語句NSString* testObject = [[NSData alloc] init];testObject 在編譯時和運行時分別時什麼類型的對象？
7.什麼是安全釋放？
8.爲何有些4.0獨有的objective－c 函數在3.1上運行時會報錯.而4.0獨有的類在3.1上分配內存時不會報錯？分配的結果是什麼？
9.爲何4.0獨有的c函數在3.1的機器上運行不會報錯（在沒有調用的狀況下？）而4.0獨有的類名在3.1的機器上一運行就報錯？
10.常見的object-c的數據類型有那些， 和 c 的 基本數據類型有什麼區別？如：nsinteger 和int
11.property中屬性retain,copy,assgin的含義分別是什麼？有什麼區別？將其轉換成get／set方法怎麼作？有什麼注意事項？
12.委託是什麼？委託的property聲明用什麼屬性？爲何？
13.淺拷貝和深拷貝區別是什麼？…
14.NSString 和 NSMutableString 有什麼區別？
15.自動釋放池跟GC有什麼區別？iPhone上有GC麼？［pool release］ 和［pool drain］有什麼區別？
16.
for(int index = 0; index < 20; index ++){
NSString *tempStr = @」tempStr」;
NSLog(tempStr);
NSNumber *tempNumber = [NSNumber numberWithInt:2];
NSLog(tempNumber);
}
這段代碼有什麼問題.？會不會形成內存泄露（多線程）？在內存緊張的設備上作大循環時自動釋放池是寫在循環內好仍是循環外好？爲何？
17.內存管理的幾條原則時什麼？按照默認法則.那些關鍵字生成的對象須要手動釋放？在和property結合的時候怎樣有效的避免內存泄露？
18.在一個對象釋放前.若是他被加到了notificationCenter 中.不在notificationcenter中remove這個對象可能會出現什麼問題？
19.怎樣實現一個 singleton的類.給出思路。
20.什麼是序列化或者Acrchiving,能夠用來作什麼,怎樣與copy結合,原理是什麼?.
21.線程是什麼？ 有哪些注意事項.?
22.在iphone上有兩件事情要作,請問是在一個線程裏按順序作效率高仍是兩個線程裏作效率高？爲何？
23.runloop是什麼？在主線程中的某個函數裏調用了異步函數，怎麼樣block當前線程,且還能響應當前線程的timer事件，touch事件等.
24.ios平臺怎麼作數據的持久化?coredata和sqlite有無必然聯繫？coredata是一個關係型數據庫嗎？
25.闡述一個nil對象從interface bulider產生，到載入程序運行空間，最後被釋放時所經歷的生命週期.
26.notification是同步仍是異步? kvo是同步仍是異步？notification是全進程空間的通知嗎？kvo呢？
27.kvc是什麼?kvo是什麼?有什麼特性？
28.響應者鏈是什麼？
29.unix上進程怎麼通訊？
30.timer的間隔週期準嗎？爲何？怎樣實現一個精準的timer?
31.UIscrollVew用到了什麼設計模式？還能再foundation庫中找到相似的嗎？
32.若是要開發一個相似eclipse的軟件，支持插件結構。且開放給第三方開發。你會怎樣去設計它？（大概思路）
33.線程和進程的區別和聯繫？
34.C和obj-c 如何混用？
35.如下每行代碼執行後，person對象的retain count分別是多少 Person *person = [[Person alloc] init]; // count 1 [person retain]; // count 2 [person release]; //count 1 [person release]; //retain count = 1;
36.ViewController 的 loadView, viewDidLoad, viewDidUnload 分別是在何時調用的?
37.ViewController 的 didReceiveMemoryWarning 是在何時被調用的？
38.ios5新特性有那些？
39.談談你對ARC 的認識和理解？
下面從第一題開始解答:
題目:1.Object－c的類能夠多重繼承麼？能夠實現多個接口麼？Category是什麼？重寫一個類的方式用繼承好仍是分類好？爲何？
關於多繼承:
首先 object-c不可以多繼承,相似下面代碼的這種方式是絕對通不過編譯的.固然,你也能夠把NSString前面的":"去掉再試試，呵呵!
那麼有沒有別的方式來替代呢？有，一種咱們稱之爲僞繼承，另外一種咱們能夠經過ios中無處不在的@protocol委託方式來實現.
1.僞繼承
儘管再objtive-C中不提供多繼承，但它提供了另一種解決方案,使對象能夠響應在其它類中實現的消息(別的語言中，通常叫方法，二者無差異). 這種解決方案叫作消息轉發，它能夠使一個類響應另一個類中實現的消息。
在通常狀況下，發送一個沒法識別的消息會產生一個運行時的錯誤，致使應用程序崩潰,可是注意，在崩潰以前，iphone運行時對象爲每一個對象提供了第二次機會來處理消息。捕捉到一條消息後能夠把它重定向到能夠響應該消息的對象。
這個功能徹底經過消息轉發來實現，發送消息給一個沒法處理該選擇器的對象時，這個選擇器就會被轉發給 forwardInvocation 方法.接收這條消息的對象，用一個NSInvocation的實例保存原始的選擇器和被請求的參數.因此，咱們能夠覆蓋 forwardInvocation 方法，並把消息轉發給另一個對象.
1.1 實現消息轉發功能
在給程序添加消息轉發功能之前，必須覆蓋兩個方法，即methodSignatureForSelector: 和 forwardInvocation:。methodSignatureForSelector:的做用在於爲另外一個類實現的消息建立一個有效的方法簽名。forwardInvocation:將選擇器轉發給一個真正實現了該消息的對象.
例子:
1.
1 - (NSMethodSignature*)methodSignatureForSelector:(SEL)selector
2 {
3 NSMethodSignature* signature = [super methodSignatureForSelector:selector];
4
5 if (!signature)
6 signature = [self.carInfo methodSignatureForSelector:selector];
7
8 return signature;
9 }
2.
1 - (void)forwardInvocation:(NSInvocation *)invocation
2 {
3 SEL selector = [invocation selector];
4
5 if ([self.carInfo respondsToSelector:selector])
6 {
7 [invocation invokeWithTarget:self.carInfo];
8 }
9 }
3.調用
1 Car *myCar = [Car car]; //Car爲一個類
2 [(NSString *)myCar UTF8String] //這裏調用NSString中的UTF8String方,注意Car中並未實現該方法
複製代碼
解釋: 這裏借iphone開發祕籍的例子來講明, self.carInfo是一個只讀的NSString對象,存在於Car類中.例子中Car實例是沒法正確的爲另一個對象(NSString)實現的選擇器建立一個有效的簽名。運行時當檢查到當前沒有有效的簽名,即進入該對象(這裏是myCar)的methodSignatureForSelector:方法中,此時，將在這個方法中對每一個僞繼承進行迭代並嘗試構建一個有效的方法簽名的機會.例如代碼中,當myCar調用UTF8String時,因爲沒法從當前對象中得到消息，轉入第二次機會捕捉消息，首先進入methodSignatureForSelector:方法,採用迭代的方式爲當前被調用的方法建立一個有效的簽名，獲得簽名後，轉入forwardInvocation:方法對其調用的方法(UTF8String)進行實現. forwardInvocation:中，首先得到調用的方法(UTF8String),判斷self.carInfo(一個nsstring對象)可否響應該方法，若是能夠，將調用UTF8String對象的目標轉換爲self.carInfo對象. 這樣 ，咱們就實現了多繼承，呵呵！！
注:若是您仍有疑問，可訪問蘋果的官方文檔查詢消息轉發相關內容:
地址 http://www.apple.com.cn/developer/mac/library/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/chapter_6_section_1.html#//
apple_ref/doc/uid/TP40008048-CH105-SW1
2.委託
在IOS中委託經過一種@protocol的方式實現,因此又稱爲協議.協議是多個類共享的一個方法列表,在協議中所列出的方法沒有響應的實現，由其它人來實現.這叫比如我想買個手機，因此我有個buyIphone 方法,可是我不知道誰那買手機,因此把這個需求發佈出去(好比公佈在網站上),若是有賣手機的商人(也就是說他能實現buyIphone這個方法)看到，他就會接受個人委託,(在商人本身的類中實現<XXXdelegate>),那麼個人委託對象就指向了這個商人..當我要買手機的時候，直接找他就好了.
例如:
@protocol MyDelegate
-(void)buyIphone:(NSString *)iphoneType money:(NSString *)money;
@end
@interface My : NSObject
{
id<MyDelegate> deleage;
}
@property(assign,nonatomic)id<MyDelegate> delegate;
@end
代碼中聲明瞭一個協議 名叫Mydelegate,在其中有一個buyIphone方法，即一個委託項。當我要購買手機的時候只須要經過delegate 調用 BuyIphone方法便可.
以下:
-(void)willbuy
{
[delegate buyIphone:@"iphone 4s" money:@"4888"];
}
我沒必要關心誰現實了這一委託，只要實現了這個委託的類，而且buyIphone是聲明的委託中必須實現的方法，那麼就必定可以獲得結果.
例如:商人類實現了這一委託(用<Mydelegate>表示實現)
#import <Foundation/Foundation.h>
#import "My.h"
@interface Business : NSObject<MyDelegate>
@end
而後在 @implementation Business 中調用 buyIphone方法
#import "Business.h"
@implementation Business
-(void)buyIphone:(NSString *)iphoneType money:(NSString *)money
{
NSLog(@"手機有貨，這個價錢賣你了，發貨中!!");
}
@end
就ok啦。這樣是否是也模擬了多繼承呢？經過委託，其實你也就擺脫了去考慮多繼承方面的事情，從而關注當前類。
- 1. 整理了網易2018屆的筆試面試題目，但願能給學弟學妹們幫助 精
- 2. 遊戲程序員面試總結---但願給有用的着的人一些幫助
- 3. iOS. 面試題（一）
- 4. iOS面試題(一)
- 5. iOS面試題一
- 6. 阿里百度12個iOS 技術面試題及答案總結，但願對你有幫助！
- 7. 2019年Android崗位BAT等大廠面試題，但願對新的一年的你有所幫助
- 8. 從事iOS研發5年的面經——但願對大家有幫助
- 9. 從事iOS研發6年的面經——但願對大家有幫助
- 10. 【面試】iOS 開發面試題(一）
- 更多相關文章...
- • Lua 調試(Debug) - Lua 教程
- • Eclipse Debug 調試 - Eclipse 教程
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
-
每一个你不满意的现在，都有一个你没有努力的曾经。