ios面试题汇总

时间 2019-11-12

标签 ios 面试汇总栏目 iOS 繁體版

原文原文链接

1.Difference between shallow copy and deep copy? 浅复制和深复制的区别？ 
答案：浅层复制：只复制指向对象的指针，而不复制引用对象自己。 深层复制：复制引用对象自己。 意思就是说我有个A对象，复制一份后获得A_copy对象后，对于浅复制来讲，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象自己资源 仍是只有一份，那若是咱们对A_copy执行了修改操做,那么发现A引用的对象一样被修改，这其实违背了咱们复制拷贝的一个思想。深复制就好理解了,内存中存在了 两份独立对象自己。 用网上一哥们通俗的话将就是： 浅复制比如你和你的影子，你完蛋，你的影子也完蛋 深复制比如你和你的克隆人，你完蛋，你的克隆人还活着。java

2.What is advantage of categories? What is difference between implementing a category and inheritance? 类别的做用？继承和类别在实现中有何区别？
答案：category 能够在不获悉，不改变原来代码的状况下往里面添加新的方法，只能添加，不能删除修改。 而且若是类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，由于类别具备更高的优先级。 类别主要有3个做用： (1)将类的实现分散到多个不一样文件或多个不一样框架中。 (2)建立对私有方法的前向引用。 (3)向对象添加非正式协议。  继承能够增长，修改或者删除方法，而且能够增长属性。ios

3.Difference between categories and extensions? 类别和类扩展的区别。
答案：category和extensions的不一样在于后者能够添加属性。另外后者添加的方法是必需要实现的。 extensions能够认为是一个私有的Category。c++

4.Difference between protocol in objective c and interfaces in java? obc中的协议和java中的接口概念有何不一样？ 
答案：OBC中的代理有2层含义，官方定义为 formal和informal protocol。前者和Java接口同样。 informal protocol中的方法属于设计模式考虑范畴，不是必须实现的，可是若是有实现，就会改变类的属性。 其实关于正式协议，类别和非正式协议我很早前学习的时候大体看过，也写在了学习教程里 “非正式协议概念其实就是类别的另外一种表达方式“这里有一些你可能但愿实现的方法，你能够使用他们更好的完成工做”。 这个意思是，这些是可选的。好比我门要一个更好的方法，咱们就会申明一个这样的类别去实现。而后你在后期能够直接使用这些更好的方法。 这么看，总以为类别这玩意儿有点像协议的可选协议。" 如今来看，其实protocal已经开始对二者都统一和规范起来操做，由于资料中说“非正式协议使用interface修饰“， 如今咱们看到协议中两个修饰词：“必须实现(@requied)”和“可选实现(@optional)”。git

5.What are KVO and KVC? 
答案：kvc:键 - 值编码是一种间接访问对象的属性使用字符串来标识属性，而不是经过调用存取方法，直接或经过实例变量访问的机制。 不少状况下能够简化程序代码。apple文档其实给了一个很好的例子。 kvo:键值观察机制，他提供了观察某一属性变化的方法，极大的简化了代码。 具体用看到嗯哼用到过的一个地方是对于按钮点击变化状态的的监控。 好比我自定义的一个button [cpp]  [self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];      #pragma mark KVO    - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context  {   if ([keyPath isEqualToString:@"highlighted"] ) {   [self setNeedsDisplay];   }  }
对于系统是根据keypath去取的到相应的值发生改变，理论上来讲是和kvc机制的道理是同样的。 对于kvc机制如何经过key寻找到value： “当经过KVC调用对象时，好比：[self valueForKey:@”someKey”]时，程序会自动试图经过几种不一样的方式解析这个调用。首先查找对象是否带有 someKey 这个方法，若是没找到，会继续查找对象是否带有someKey这个实例变量（iVar），若是尚未找到，程序会继续试图调用 -(id) valueForUndefinedKey:这个方法。若是这个方法仍是没有被实现的话，程序会抛出一个NSUndefinedKeyException异常错误。   (cocoachina.com注：Key-Value Coding查找方法的时候，不只仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及_getsomeKey这几种形式。同时，查找实例变量的时候也会不只仅查找someKey这个变量，也会查找_someKey这个变量是否存在。）   设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象可以在错误发生前，有最后的机会响应这个请求。这样作有不少好处，下面的两个例子说明了这样作的好处。“ 来至cocoa，这个说法应该挺有道理。 由于咱们知道button倒是存在一个highlighted实例变量.所以为什么上面咱们只是add一个相关的keypath就好了， 能够按照kvc查找的逻辑理解，就说的过去了。程序员

6.What is purpose of delegates? 代理的做用？
答案：代理的目的是改变或传递控制链。容许一个类在某些特定时刻通知到其余类，而不须要获取到那些类的指针。能够减小框架复杂度。 另一点，代理能够理解为java中的回调监听机制的一种相似。github

7.What are mutable and immutable types in Objective C? obc中可修改和不能够修改类型。 
答案：可修改不可修改的集合类。这个我我的简单理解就是可动态添加修改和不可动态添加修改同样。 好比NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者能够添加等，能够动态申请新的内存空间。web

8.When we call objective c is runtime language what does it mean? 咱们说的obc是动态运行时语言是什么意思？ 
答案：多态。主要是将数据类型的肯定由编译时，推迟到了运行时。 这个问题其实浅涉及到两个概念，运行时和多态。 简单来讲，运行时机制使咱们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。 多态：不一样对象以本身的方式响应相同的消息的能力叫作多态。意思就是假设生物类（life）都用有一个相同的方法-eat; 那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，可是调用是咱们只需调用各自的eat方法。 也就是不一样的对象以本身的方式响应了相同的消息（响应了eat这个选择器）。 所以也能够说，运行时机制是多态的基础？~~~面试

9.what is difference between NSNotification and protocol? 通知和协议的不一样之处？ 
答案：协议有控制链(has-a)的关系，通知没有。 首先我一开始也不太明白，什么叫控制链（专业术语了~）。可是简单分析下通知和代理的行为模式，咱们大体能够有本身的理解 简单来讲，通知的话，它能够一对多，一条消息能够发送给多个消息接受者。 代理按咱们的理解，到不是直接说不能一对多，好比咱们知道的明星经济代理人，不少时候一个经济人负责好几个明星的事务。 只是对于不一样明星间，代理的事物对象都是不同的，一一对应，不可能说明天要处理A明星要一个发布会，代理人发出处理发布会的消息后，别称B的 发布会了。可是通知就不同，他只关心发出通知，而不关心多少接收到感兴趣要处理。 所以控制链（has-a从英语单词大体能够看出，单一拥有和可控制的对应关系。objective-c

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

11.Polymorphism？ 关于多态性 
答案：多态，子类指针能够赋值给父类。 这个题目其实能够出到一切面向对象语言中， 所以关于多态，继承和封装基本最好都有个自我意识的理解，也并不是必定要把书上资料上写的能背出来。 最重要的是转化成自我理解。

12.Singleton? 对于单例的理解 
答案：11，12题目其实出的有点泛泛的感受了，可能说是编程语言须要或是必备的基础。 基本能用熟悉的语言写出一个单例，以及能够运用到的场景或是你编程中碰到过运用的此种模式的框架类等。 进一步点，考虑下如何在多线程访问单例时的安全性。

13.What is responder chain? 说说响应链 
答案：事件响应链。包括点击事件，画面刷新事件等。在视图栈内从上至下，或者从下之上传播。 能够说点事件的分发，传递以及处理。具体能够去看下touch事件这块。由于问的太抽象化了 严重怀疑题目出到越后面就越笼统。

14.Difference between frame and bounds? frame和bounds有什么不一样？ 
答案:frame指的是：该view在父view坐标系统中的位置和大小。（参照点是父亲的坐标系统） bounds指的是：该view在自己坐标系统中的位置和大小。（参照点是自己坐标系统）

15.Difference between method and selector? 方法和选择器有何不一样？ 
答案：selector是一个方法的名字，method是一个组合体，包含了名字和实现. 详情能够看apple文档。

16.Is there any garbage collection mechanism in Objective C.? OBC的垃圾回收机制？ 
答案： OBC2.0有Garbage collection，可是iOS平台不提供。 通常咱们了解的objective-c对于内存管理都是手动操做的，可是也有自动释放池。 可是差了大部分资料，貌似不要和arc机制搞混就行了。 求更多~~

17.NSOperation queue? 
答案：存放NSOperation的集合类。 操做和操做队列，基本能够当作java中的线程和线程池的概念。用于处理ios多线程开发的问题。 网上部分资料提到一点是，虽然是queue，可是却并非带有队列的概念，放入的操做并不是是按照严格的先进现出。 这边又有个疑点是，对于队列来讲，先进先出的概念是Afunc添加进队列，Bfunc紧跟着也进入队列，Afunc先执行这个是必然的， 可是Bfunc是等Afunc彻底操做完之后，B才开始启动而且执行，所以队列的概念离乱上有点违背了多线程处理这个概念。 可是转念一想其实能够参考银行的取票和叫号系统。 所以对于A比B先排队取票可是B率先执行完操做，咱们亦然能够感性认为这仍是一个队列。 可是后来看到一票关于这操做队列话题的文章，其中有一句提到 “由于两个操做提交的时间间隔很近，线程池中的线程，谁先启动是不定的。” 瞬间以为这个queue名字有点忽悠人了，还不如pool~ 综合一点，咱们知道他能够比较大的用处在于能够帮组多线程编程就行了。

18.What is lazy loading? 
答案：懒汉模式，只在用到的时候才去初始化。 也能够理解成延时加载。 我以为最好也最简单的一个列子就是tableView中图片的加载显示了。 一个延时载，避免内存太高，一个异步加载，避免线程堵塞。

19.Can we use two tableview controllers on one viewcontroller? 是否在一个视图控制器中嵌入两个tableview控制器？ 
答案：一个视图控制只提供了一个View视图，理论上一个tableViewController也不能放吧， 只能说能够嵌入一个tableview视图。固然，题目自己也有歧义，若是不是咱们定性思惟认为的UIViewController， 而是宏观的表示视图控制者，那咱们却是能够把其当作一个视图控制者，它能够控制多个视图控制器，好比TabbarController 那样的感受。

20.Can we use one tableview with two different datasources? How you will achieve this? 一个tableView是否能够关联两个不一样的数据源？你会怎么处理？ 
答案：首先咱们从代码来看，数据源如何关联上的，实际上是在数据源关联的代理方法里实现的。 所以咱们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据本身的须要去设置如相关的数据源。 所以，我以为能够设置多个数据源啊，可是有个问题是，你这是想干吗呢？想让列表如何显示，不一样的数据源分区块显示？

21.Object－c的类能够多重继承么？能够实现多个接口么？重写一个类的方式用继承好仍是分类好？为何？
Objective-c只支持单继承，若是要实现多继承的话，能够经过类别和协议的方式来实现，cocoa 中全部的类都是NSObject 的子类，多继承在这里是用protocol 委托代理来实现的。

22.#import 跟#include 又什么区别＃import<> 跟 #import""又什么区别？
答案：@class通常用于头文件中须要声明该类的某个实例变量的时候用到，在m文件中仍是须要使用#import而#import比起#include的好处就是不会引发交叉编译。

23.类变量的@protected ,@private,@public,@package声明各有什么含义？

24.id 声明的对象有什么特性？
答案：id是个很重要的类型，是个能够指向任何类型的指针或者能够理解为指向任何未知类型的指针。

25.MVC是什么？有什么特性？为何在iPhone上被普遍运用？
答案：MVC设计模式考虑三种对象：模型对象、视图对象、和控制器对象。模型对象表明特别的知识和专业技能，它们负责保有应用程序的数据和定义操做数据的逻辑。视图对象知道如何显示应用程序的模型数据，并且可能容许用户对其进行编辑。控制器对象是应用程序的视图对象和模型对象之间的协调者。

26.对于语句NSString* testObject = [[NSData alloc] init];testObject 在编译时和运行时分别是什么类型的对象？

27.什么是安全释放？

28.为何有些4.0独有的objective－c 函数在3.1上运行时会报错.而4.0独有的类在3.1上分配内存时不会报错？分配的结果是什么？

29.为何4.0独有的c函数在3.1的机器上运行不会报错（在没有调用的状况下？）而4.0独有的类名在3.1的机器上一运行就报错？

30.异常exception 怎么捕获？不一样的CPU结构上开销怎样？C中又什么相似的方法？

31.property中属性retain,copy,assgin的含义分别是什么？有什么区别？将其转换成get／set方法怎么作？有什么注意事项？

32.委托是什么？委托的property声明用什么属性？为何？

34.Cocoa中有虚基类的概念么？怎么简洁的实现？

35.自动释放池跟GC（垃圾回收）有什么区别？iPhone上有GC么？［pool release］和［pool drain］有什么区别？
iPhone上没有GC。iPhone开发的时候没有垃圾回收机制。
在垃圾回收环境中，release是一个空操做。所以，NSAutoreleasePool提供了drain方法，在引用计数环境中，该方法的做用等同于调用release，但在垃圾回收环境中，它会触发垃圾回收（若是自上次垃圾回收以来分配的内存大于当前的阈值）。所以，在一般状况下，您应该使用drain而不是release来销毁自动释放池。

36.
for(int index = 0; index < 20; index ++){
NSString *tempStr = @”tempStr”;
NSLog(tempStr);
NSNumber *tempNumber = [NSNumber numberWithInt:2];
NSLog(tempNumber);
}
这段代码有什么问题.？会不会形成内存泄露（多线程）？在内存紧张的设备上作大循环时自动释放池是写在循环内好仍是循环外好？为何？

37.内存管理的几条原则时什么？按照默认法则.那些关键字生成的对象须要手动释放？在和property结合的时候怎样有效的避免内存泄露？

38.在一个对象释放前.若是他被加到了notificationCenter 中.不在notificationcenter中remove这个对象可能会出现什么问题？

39.怎样实现一个 singleton的类.给出思路。

40.什么是序列化或者Acrchiving,能够用来作什么,怎样与copy结合,原理是什么?.

41. 线程与进程的区别和联系?
答案: 进程和线程都是由操做系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。
程和线程的主要差异在于它们是不一样的操做系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不一样执行路径。线程有本身的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，因此多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行而且又要共享某些变量的并发操做，只能用线程，不能用进程。

42.在iphone上有两件事情要作,请问是在一个线程里按顺序作效率高仍是两个线程里作效率高？为何？

43.runloop是什么？在主线程中的某个函数里调用了异步函数，怎么样block当前线程,且还能响应当前线程的timer事件，touch事件等.

44.ios平台怎么作数据的持久化?coredata和sqlite有无必然联系？coredata是一个关系型数据库吗？
iOS中能够有四种持久化数据的方式：属性列表、对象归档、SQLite3和Core Data；core data能够使你以图形界面的方式快速的定义app的数据模型，同时在你的代码中容易获取到它。core data提供了基础结构去处理经常使用的功能，例如保存，恢复，撤销和重作，容许你在app中继续建立新的任务。在使用core data的时候，你不用安装额外的数据库系统，由于core data使用内置的sqlite数据库。core data将你app的模型层放入到一组定义在内存中的数据对象。core data会追踪这些对象的改变，同时能够根据须要作相反的改变，例如用户执行撤销命令。当core data在对你app数据的改变进行保存的时候，core data会把这些数据归档，并永久性保存。
mac os x中sqlite库，它是一个轻量级功能强大的关系数据引擎，也很容易嵌入到应用程序。能够在多个平台使用，sqlite是一个轻量级的嵌入式sql数据库编程。与core data框架不一样的是，sqlite是使用程序式的，sql的主要的API来直接操做数据表。
Core Data不是一个关系型数据库，也不是关系型数据库管理系统(RDBMS)。虽然Core Dta支持SQLite做为一种存储类型，但它不能使用任意的SQLite数据库。Core Data在使用的过程种本身建立这个数据库。Core Data支持对1、对多的关系。

45.阐述一个nil对象从interface bulider产生，到载入程序运行空间，最后被释放时所经历的生命周期.

46.notification是同步仍是异步? kvo是同步仍是异步？notification是全进程空间的通知吗？kvo呢？

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

~~48.响应者链是什么？~~

49.unix上进程怎么通讯？

UNIX主要支持三种通讯方式：

1. 基本通讯：主要用来协调进程间的同步和互斥

(1)锁文件通讯

通讯的双方经过查找特定目录下特定类型的文件(称锁文件)来完成进程间对临界资源访问时的互斥；例如进程p1访问一个临界资源，首先查看是否有一个特定类型文件，如有，则等待一段时间再查找锁文件。

(2)记录锁文件

2. 管道通讯：适应大批量的数据传递

3. IPC ：适应大批量的数据传递

50.timer的间隔周期准吗？为何？怎样实现一个精准的timer?

51.UIscrollVew用到了什么设计模式？还能再foundation库中找到相似的吗？（答案众多，不知道哪一个是对的～～）

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

组合模式composition，全部的containerview都用了这个模式

观察者模式observer，全部的UIResponder都用了这个模式。

52若是要开发一个相似eclipse的软件，支持插件结构。且开放给第三方开发。你会怎样去设计它？（大概思路）

53. main()

{

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

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

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

}

答：2,5

*(a+1)就是a[1]，*(ptr-1)就是a[4],执行结果是2.5 ，&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int，int *ptr=(int *)(&a+1); 则ptr实际是&(a[5]),也就是a+5 缘由以下：

　　&a是数组指针，其类型为 int (*)[5]; 而指针加1要根据指针类型加上必定的值，不一样类型的指针+1以后增长的大小不一样。a是长度为5的int数组指针，因此要加 5*sizeof(int)因此ptr实际是a[5]，可是prt与(&a+1)类型是不同的(这点很重要)，因此prt-1只会减去sizeof(int*)，a,&a的地址是同样的，但意思不同，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].

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

答案：这题很常见了,Func( char str[100] )函数中数组名做为函数形参时，在函数体内，数组名失去了自己的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，能够做自增、自减等操做，能够被修改。Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof( p ) 都为4。

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

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

return ;}

-main(void)

{NSString *a=@"Main";

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

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

最后问输出的字符串:NULL,output在函数返回后，内存已经被释放。

56.列举几种进程的同步机制，并比较其优缺点。

答案：原子操做信号量机制自旋锁管程，会合，分布式系统  

进程之间通讯的途径

答案：共享存储系统消息传递系统管道：以文件系统为基础

进程死锁的缘由

答案：资源竞争及进程推动顺序非法

死锁的4个必要条件

答案：互斥、请求保持、不可剥夺、环路

死锁的处理

答案：鸵鸟策略、预防策略、避免策略、检测与解除死锁

57.堆和栈的区别

管理方式：对于栈来说，是由编译器自动管理，无需咱们手工控制；对于堆来讲，释放工做由程序员控制，容易产生memory leak。

申请大小： 栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就肯定的常数），若是申请的空间超过栈的剩余空间时，将提示overflow。所以，能从栈得到的空间较小。 堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是因为系统是用链表来存储的空闲内存地址的，天然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。因而可知，堆得到的空间比较灵活，也比较大。

碎片问题：对于堆来说，频繁的new/delete势必会形成内存空间的不连续，从而形成大量的碎片，使程序效率下降。对于栈来说，则不会存在这个问题，由于栈是先进后出的队列，他们是如此的一一对应，以致于永远都不可能有一个内存块从栈中间弹出

分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，好比局部变量的分配。动态分配由alloca函数进行分配，可是栈的动态分配和堆是不一样的，他的动态分配是由编译器进行释放，无需咱们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的。

58.什么是键-值,键路径是什么?

模型的性质是经过一个简单的键（一般是个字符串）来指定的。视图和控制器经过键来查找相应的属性值。在一个给定的实体中，同一个属性的全部值具备相同的数据类型。键-值编码技术用于进行这样的查找—它是一种间接访问对象属性的机制。

键路径是一个由用点做分隔符的键组成的字符串，用于指定一个链接在一块儿的对象性质序列。第一个键的 性质是由先前的性质决定的，接下来每一个键的值也是相对于其前面的性质。键路径使您能够以独立于模型 实现的方式指定相关对象的性质。经过键路径，您能够指定对象图中的一个任意深度的路径，使其指向相 关对象的特定属性。

59.c和obj-c如何混用

1）obj-c的编译器处理后缀为m的文件时，能够识别obj-c和c的代码，处理mm文件能够识别obj-c,c,c++代码，但cpp文件必须只能用c/c++代码，并且cpp文件include的头文件中，也不能出现obj- c的代码，由于cpp只是cpp 2) 在mm文件中混用cpp直接使用便可，因此obj-c混cpp不是问题 3）在cpp中混用obj- c其实就是使用obj-c编写的模块是咱们想要的。 若是模块以类实现，那么要按照cpp class的标准写类的定义，头文件中不能出现obj-c的东西，包括#import cocoa的。实现文件中，即类的实现代码中能够使用obj-c的东西，能够import,只是后缀是mm。 若是模块以函数实现，那么头文件要按 c的格式声明函数，实现文件中，c++函数内部能够用obj-c，但后缀仍是mm或m。  总结：只要cpp文件和cpp include的文件中不包含obj-c的东西就能够用了，cpp混用obj-c的关键是使用接口，而不能直接使用实现代码，实际上cpp混用的是 obj-c编译后的o文件，这个东西实际上是无差异的，因此能够用。obj-c的编译器支持cpp.

60.目标-动做机制

目标是动做消息的接收者。一个控件，或者更为常见的是它的单元，以插座变量（参见"插座变量"部分） 的形式保有其动做消息的目标。

动做是控件发送给目标的消息，或者从目标的角度看，它是目标为了响应动做而实现的方法。

程序须要某些机制来进行事件和指令的翻译。这个机制就是目标-动做机制。

61.cocoatouch框架

iPhoneOS 应用程序的基础Cocoa Touch 框架重用了许多 Mac 系统的成熟模式，可是它更多地专一于触摸的接口和优化。UIKit 为您提供了在 iPhone OS 上实现图形，事件驱动程序的基本工具，其创建在和 Mac OS X 中同样的 Foundation 框架上，包括文件处理，网络，字符串操做等。

CocoaTouch 具备和 iPhone 用户接口一致的特殊设计。有了 UIKit，您能够使用 iPhone OS 上的独特的图形接口控件，按钮，以及全屏视图的功能，您还能够使用加速仪和多点触摸手势来控制您的应用。

各色俱全的框架除了UIKit 外，Cocoa Touch 包含了建立世界一流iPhone 应用程序须要的全部框架，从三维图形，到专业音效，甚至提供设备访问 API 以控制摄像头，或经过 GPS 获知当前位置。Cocoa Touch 既包含只须要几行代码就能够完成所有任务的强大的 Objective-C 框架，也在须要时提供基础的 C 语言 API 来直接访问系统。这些框架包括：

CoreAnimation

经过 CoreAnimation，您就能够经过一个基于组合独立图层的简单的编程模型来建立丰富的用户体验。

CoreAudio

CoreAudio 是播放，处理和录制音频的专业技术，可以轻松为您的应用程序添增强大的音频功能。

CoreData

提供了一个面向对象的数据管理解决方案，它易于使用和理解，甚至可处理任何应用或大或小的数据模型。

功能列表：框架分类

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

• 音频和视频

• Core Audio

• OpenAL

• Media Library

• AV Foundation

• 数据管理

• Core Data

• SQLite

• 图形和动画

• Core Animation

• OpenGL ES

• Quartz 2D

• 网络/li>

• Bonjour

• WebKit

• BSD Sockets

• 用户应用

• Address Book

• Core Location

• Map Kit

• Store Kit

62.objc的内存管理

若是您经过分配和初始化（好比[[MyClass alloc] init]）的方式来建立对象，您就拥 有这个对象，须要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也一样适用.

若是您拷贝一个对象，您也拥有拷贝获得的对象，须要负责该对象的释放.

若是您保持一个对象，您就部分拥有这个对象，须要在再也不使用时释放该对象。

若是您从其它对象那里接收到一个对象，则您不拥有该对象，也不该该释放它（这个规则有少数 的例外，在参考文档中有显式的说明）。

63.自动释放池是什么,如何工做

当您向一个对象发送一个autorelease消息时，Cocoa就会将该对象的一个引用放入到最新的自动释放池。它仍然是个正当的对象，所以自动释放池定义的做用域内的其它对象能够向它发送消息。当程序执行到做用域结束的位置时，自动释放池就会被释放，池中的全部对象也就被释放。

1. ojc-c 是经过一种"referringcounting"(引用计数)的方式来管理内存的, 对象在开始分配内存(alloc)的时候引用计数为一,之后每当碰到有copy,retain的时候引用计数都会加一, 每当碰到release和autorelease的时候引用计数就会减一,若是此对象的计数变为了0, 就会被系统销毁. 2. NSAutoreleasePool 就是用来作引用计数的管理工做的,这个东西通常不用你管的. 3. autorelease和release没什么区别,只是引用计数减一的时机不一样而已,autorelease会在对象的使用真正结束的时候才作引用计数减一.

64.类工厂方法是什么

类工厂方法的实现是为了向客户提供方便，它们将分配和初始化合在一个步骤中，返回被建立的对象，并 进行自动释放处理。这些方法的形式是+ (type)className...（其中 className不包括任何前缀）。

工厂方法可能不只仅为了方便使用。它们不但能够将分配和初始化合在一块儿，还能够为初始化过程提供对 象的分配信息。

类工厂方法的另外一个目的是使类（好比NSWorkspace）提供单件实例。虽然init...方法能够确认一 个类在每次程序运行过程只存在一个实例，但它须要首先分配一个“生的”实例，而后还必须释放该实例。 工厂方法则能够避免为可能没有用的对象盲目分配内存。

65.单件实例是什么

Foundation和Application Kit 框架中的一些类只容许建立单件对象，即这些类在当前进程中的惟一实例。举例来讲，NSFileManager和NSWorkspace 类在使用时都是基于进程进行单件对象的实例化。当向这些类请求实例的时候，它们会向您传递单一实例的一个引用，若是该实例还不存在，则首先进行实例的分配和初始化。单件对象充当控制中心的角色，负责指引或协调类的各类服务。若是类在概念上只有一个实例（好比 NSWorkspace），就应该产生一个单件实例，而不是多个实例；若是未来某一天可能有多个实例，您可 以使用单件实例机制，而不是工厂方法或函数。

66.动态绑定—在运行时肯定要调用的方法

动态绑定将调用方法的肯定也推迟到运行时。在编译时，方法的调用并不和代码绑定在一块儿，只有在消实发送出来以后，才肯定被调用的代码。经过动态类型和动态绑定技术，您的代码每次执行均可以获得不一样的结果。运行时因子负责肯定消息的接收者和被调用的方法。运行时的消息分发机制为动态绑定提供支持。当您向一个动态类型肯定了的对象发送消息时，运行环境系统会经过接收者的isa指针定位对象的类，并以此为起点肯定被调用的方法，方法和消息是动态绑定的。并且，您没必要在Objective-C 代码中作任何工做，就能够自动获取动态绑定的好处。您在每次发送消息时，

 特别是当消息的接收者是动态类型已经肯定的对象时，动态绑定就会例行而透明地发生。

67.obj-c的优缺点

objc优势：  1)Cateogies   2) Posing   3) 动态识别  4) 指标计算   5）弹性讯息传递  6) 不是一个过分复杂的 C 衍生语言  7) Objective-C 与 C++ 可混合编程 

缺点:   1) 不支援命名空間   2) 不支持运算符重载

3）不支持多重继承

4）使用动态运行时类型，全部的方法都是函数调用，因此不少编译时优化方法都用不到。（如内联函数等），性能低劣。

68.readwrite，readonly，assign，retain，copy，nonatomic 属性的做用？

@property是一个属性访问声明，扩号内支持如下几个属性： 1，getter=getterName，setter=setterName，设置setter与 getter的方法名 2，readwrite,readonly，设置可供访问级别 2，assign，setter方法直接赋值，不进行任何retain操做，为了解决原类型与环循引用问题 3，retain，setter方法对参数进行release旧值再retain新值，全部实现都是这个顺序(CC上有相关资料) 4，copy，setter方法进行Copy操做，与retain处理流程一样，先旧值release，再 Copy出新的对象，retainCount为1。这是为了减小对上下文的依赖而引入的机制。 5，nonatomic，非原子性访问，不加同步，多线程并发访问会提升性能。注意，若是不加此属性，则默认是两个访问方法都为原子型事务访问。锁被加到所属对象实例级(我是这么理解的…)。

~~69.ViewController的 didReceiveMemoryWarning 是在何时被调用的？~~（87题）

70.谈谈你对ARC 的认识和理解？

71. ObjC中，与alloc语义相反的方法是dealloc仍是release？与retain语义相反的方法是dealloc仍是release，为何？须要与alloc配对使用的方法是dealloc仍是release，为何？

alloc与dealloc语意相反，alloc是建立变量，dealloc是释放变量。 retain 对应release,retain 保留一个对象。调用以后，变量的计数加1。或许不是很明显，在这有例为证：

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

[name retain];

[myname release];

myname = name; }

咱们来解释一下：设想，用户在调用这个函数的时候，他注意了内存的管理，因此他当心的写了以下代码：

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

[aClasssetName: newname];

[newnamerelease];

咱们来看一看newname的计数是怎么变化的。首先，它被alloc，count = 1; 而后，在setName中，它被retain，count = 2; 最后，用户本身释放newname，count= 1，myname指向了newname。这也解释了为何须要调用[myname release]。咱们须要在给myname赋新值的时候，释放掉之前老的变量。retain 以后直接dealloc对象计数器没有释放。alloc 须要与release配对使用，由于alloc 这个函数调用以后，变量的计数加1。因此在调用alloc 以后，必定要调用对应的release。另外，在release一个变量以后，他的值仍然有效，因此最好是后面紧接着再var = nil。

72. 在一个对象的方法里面:

self.name = “object”;

和

name ＝”object”

有什么不一样?

73. 这段代码有什么问题:

@implementation Person

- (void)setAge:(int)newAge {

self.age = newAge;

}

@end

74. 什么是retaincount?

75. 如下每行代码执行后，person对象的retain count分别是多少

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

[person retain];

[person release];

76. 为何不少内置类如UITableViewController的delegate属性都是assign而不是retain的？

77. 定义属性时，什么状况使用copy，assign，和retain？

assign用于简单数据类型，如NSInteger,double,bool,retain和copy用户对象，copy用于当 a指向一个对象，b也想指向一样的对象的时候，若是用assign，a若是释放，再调用b会crash,若是用copy 的方式，a和b各自有本身的内存，就能够解决这个问题。retain 会使计数器加一，也能够解决assign的问题。另外：atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操做。在多线程环境下，原子操做是必要的，不然有可能引发错误的结果。加了atomic，setter函数会变成下面这样：

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

78. autorelease的对象是在何时被release的？

答：autorelease实际上只是把对release的调用延迟了，对于每个Autorelease，系统只是把该Object放入了当前的Autoreleasepool中，当该pool被释放时，该pool中的全部Object会被调用Release。对于每个Runloop，系统会隐式建立一个Autoreleasepool，这样全部的releasepool会构成一个象CallStack同样的一个栈式结构，在每个Runloop结束时，当前栈顶的Autoreleasepool会被销毁，这样这个pool里的每一个Object（就是autorelease的对象）会被release。那什么是一个Runloop呢？一个UI事件，Timer call，delegate call，都会是一个新的Runloop。那什么是一个Runloop呢？一个UI事件，Timer call，delegate call，都会是一个新的Runloop。

79. 这段代码有什么问题,如何修改

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

{

NSString *string = @”Abc”;

string = [string lowercaseString];

string = [stringstringByAppendingString:@"xyz"];

NSLog(@“%@”, string);

}

~~80. autorelease和垃圾回收机制(gc)有什么关系？IPhone OS有没有垃圾回收（gc）？~~

81. Objective C中的protocal是什么？

@protocal obj里面的协议就如同java里面的interface。

82. Objective C中的selector 是什么？

你能够理解 @selector()就是取类方法的编号,他的行为基本能够等同C语言的中函数指针,只不过C语言中，能够把函数名直接赋给一个函数指针，而Objective-C的类不能直接应用函数指针，这样只能作一个@selector语法来取.它的结果是一个SEL类型。这个类型本质是类方法的编号(函数地址)。

83. Objective C中的category是什么?

Objective-C提供了一个很是灵活的类(Class)扩展机制－类别(Category)。类别用于对一个已经存在的类添加方法(Methods)。你只须要知道这个类的公开接口，不须要知道类的源代码。须要注意的是，类别不能为已存在的类添加实例变量(Instance Variables)。

子类(subclassing)是进行类扩展的另外一种经常使用方法。与子类相比，类别最主要的优势是：系统中已经存在的类能够不需修改就可以使用类别的扩展功能。

类别的第二大优势是实现了功能的局部化封装。类别定义能够放在一个已存在的类(类A)的定义文件中(.h)。这意味着这个类别只有在类A被引用的前提下才会被外部看到。若是另外一个类(类B)不须要用到类A的功能(没有包含类A的.h文件)，也就不会看到依附类A存在的类别。iOS SDK中普遍运用这种类别定义法来封装功能。

84. 什么是Notification？何时用delegate，何时用Notification？

观察者模式，controller向defaultNotificationCenter添加本身的notification，其余类注册这个notification就能够收到通知，这些类能够在收到通知时作本身的操做（多观察者默认随机顺序发通知给观察者们，并且每一个观察者都要等当前的某个观察者的操做作完才能轮到他来操做，能够用NotificationQueue的方式安排观察者的反应顺序，也能够在添加观察者中设定反映时间，取消观察须要在viewDidUnload跟dealloc中都要注销）。

delegate针对one-to-one关系，而且reciever能够返回值给sender，notification能够针对one-to-one/many/none,reciever没法返回值给sender.因此，delegate用于sender但愿接受到reciever的某个功能反馈值，

notification用于通知多个object某个事件。

85. ~~什么是KVC和KVO？~~Notification和KVO有什么不一样？KVO在ObjC中是怎么实现的？

86. ViewController 的 loadView,viewDidLoad, viewDidUnload 分别是在何时调用的？在自定义ViewController的时候这几个函数里面应该作什么工做？

答：viewDidLoad在view 从nib文件初始化时调用，loadView在controller的view为nil时调用。此方法在编程实现view时调用,view 控制器默认会注册memory warning notification,当view controller的任何view 没有用的时候，viewDidUnload会被调用，在这里实现将retain 的view release,若是是retain的IBOutlet view 属性则不要在这里release,IBOutlet会负责release 。

87. ViewController 的didReceiveMemoryWarning 是在何时被调用的？UIViewController类中didReceiveMemoryWarning默认的操做是什么？

答：默认调用[superdidReceiveMemoryWarning]

88. UITableViewController 中，建立UITableViewCell时，initWithSytle:resuseIdentifier中，reuseIdentifier有什么用？简述UITableViewCell的复用原理.

复用队列的元素增长：只有在cell被滑动出界面的时候，此cell才会被加入到复用队列中。每次在建立cell的时候，程序会首先经过调用dequeueReusableCellWithIdentifier:cellType方法，到复用队列中去寻找标示符为“cellType”的cell，若是找不到，返回nil，而后程序去经过调用[[[UITableViewCell alloc]initWithStyle:style reuseIdentifier:cellType] autorelease]来建立标示符为“cellType”的cell。

89. UIView 和CALayer 有什么区别?

二者最大的区别是，图层不会直接渲染到屏幕上。

90. 以 UIView 类animateWithDuration:animations: 为例，简述UIView动画原理

copy与retain：
一、copy实际上是创建了一个相同的对象，而retain不是；
二、copy是内容拷贝，retain是指针拷贝；
三、copy是内容的拷贝 ,对于像NSString,的确是这样，可是若是copy的是一个NSArray呢?这时只是copy了指向array中相对应元素的指针.这即是所谓的"浅复制".
四、copy的状况：NSString *newPt = [pt copy];
此时会在堆上从新开辟一段内存存放@"abc" 好比0X1122 内容为@"abc 同时会在栈上为newPt分配空间好比地址：0Xaacc 内容为0X1122 所以retainCount增长1供newPt来管理0X1122这段内存；
assign与retain：
一、assign: 简单赋值，不更改索引计数；
二、assign的状况：NSString *newPt = [pt assing];

此时newPt和pt彻底相同地址都是0Xaaaa 内容为0X1111 即newPt只是pt的别名，对任何一个操做就等于对另外一个操做，所以retainCount不须要增长；

三、assign就是直接赋值；
四、retain使用了引用计数，retain引发引用计数加1, release引发引用计数减1，当引用计数为0时，dealloc函数被调用，内存被回收；

五、retain的状况：NSString *newPt = [pt retain];

此时newPt的地址再也不为0Xaaaa，可能为0Xaabb 可是内容依然为0X1111。所以newPt 和 pt 均可以管理"abc"所在的内存，所以 retainCount须要增长1 ；
readonly：
一、属性是只读的，默认的标记是读写，若是你指定了只读，在@implementation中只须要一个读取器。或者若是你使用@synthesize关键字，也是有读取器方法被解析
readwrite：
一、说明属性会被当成读写的，这也是默认属性。设置器和读取器都须要在@implementation中实现。若是使用@synthesize关键字，读取器和设置器都会被解析；
nonatomic：
一、非原子性访问，对属性赋值的时候不加锁，多线程并发访问会提升性能。若是不加此属性，则默认是两个访问方法都为原子型事务访问；
weak and strong property (强引用和弱引用的区别)：
一、 weak 和 strong 属性只有在你打开ARC时才会被要求使用，这时你是不能使用retain release autorelease 操做的，由于ARC会自动为你作好这些操做，可是你须要在对象属性上使用weak 和strong,其中strong就至关于retain属性，而weak至关于assign。
二、只有一种状况你须要使用weak（默认是strong），就是为了不retain cycles（就是父类中含有子类{父类retain了子类}，子类中又调用了父类{子类又retain了父类}，这样都没法release）
三、声明为weak的指针，指针指向的地址一旦被释放，这些指针都将被赋值为nil。这样的好处能有效的防止野指针。

ARC(Automatic Reference Counting):
一、就是代码中自动加入了retain/release，原先须要手动添加的用来处理内存管理的引用计数的代码能够自动地由编译器完成了。

该机能在 iOS 5/ Mac OS X 10.7 开始导入，利用 Xcode4.2 之后能够使用该特性。
strong,weak,copy 具体用法：

1.具体一点：IBOutlet能够为weak，NSString为copy，Delegate通常为weak，其余的看状况。通常来讲，类“内部”的属性设置为strong，类“外部”的属性设置为weak。说到底就是一个归属权的问题。当心出现循环引用致使内存没法释放。
2.不用ARC的话就会看到不少retian。
3.若是你写了@synthesize abc = _abc；的话，系统自动帮你声明了一个_abc的实例变量。
使用assign: 对基础数据类型（NSInteger）和C数据类型（int, float, double, char,等）
使用copy：对NSString

使用retain：对其余NSObject和其子类

1.写一个NSString类的实现

+ (id)initWithCString:(c*****t char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;

+ (id) stringWithCString: (c*****t char*)nullTerminatedCString

encoding: (NSStringEncoding)encoding

{

NSString *obj;

obj = [self allocWithZone: NSDefaultMallocZone()];

obj = [obj initWithCString: nullTerminatedCString encoding: encoding];

return AUTORELEASE(obj);

}

2static 关键字的做用：

（1）函数体内 static 变量的做用范围为该函数体，不一样于 auto 变量，该变量的内存只被分配一次，

所以其值在下次调用时仍维持上次的值；

（2）在模块内的 static 全局变量能够被模块内所用函数访问，但不能被模块外其它函数访问；

（3）在模块内的 static 函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明

它的模块内；

（4）在类中的 static 成员变量属于整个类所拥有，对类的全部对象只有一份拷贝；

（5）在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，于是只能访问类的static 成员变量。

3线程与进程的区别和联系?

进程和线程都是由操做系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。

程和线程的主要差异在于它们是不一样的操做系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不一样执行路径。线程有本身的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，因此多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行而且又要共享某些变量的并发操做，只能用线程，不能用进程。

4堆和栈的区别

管理方式：对于栈来说，是由编译器自动管理，无需咱们手工控制；对于堆来讲，释放工做由程序员控制，容易产生memory leak。

申请大小：

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就肯定的常数），若是申请的空间超过栈的剩余空间时，将提示overflow。所以，能从栈得到的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是因为系统是用链表来存储的空闲内存地址的，天然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。因而可知，堆得到的空间比较灵活，也比较大。

碎片问题：对于堆来说，频繁的new/delete势必会形成内存空间的不连续，从而形成大量的碎片，使程序效率下降。对于栈来说，则不会存在这个问题，由于栈是先进后出的队列，他们是如此的一一对应，以致于永远都不可能有一个内存块从栈中间弹出

分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，好比局部变量的分配。动态分配由alloca函数进行分配，可是栈的动态分配和堆是不一样的，他的动态分配是由编译器进行释放，无需咱们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的。

5什么是键-值,键路径是什么

键路径是一个由用点做分隔符的键组成的字符串，用于指定一个链接在一块儿的对象性质序列。第一个键的

性质是由先前的性质决定的，接下来每一个键的值也是相对于其前面的性质。键路径使您能够以独立于模型

实现的方式指定相关对象的性质。经过键路径，您能够指定对象图中的一个任意深度的路径，使其指向相

关对象的特定属性。

6目标-动做机制

目标是动做消息的接收者。一个控件，或者更为常见的是它的单元，以插座变量（参见"插座变量"部分）

的形式保有其动做消息的目标。

动做是控件发送给目标的消息，或者从目标的角度看，它是目标为了响应动做而实现的方法。

程序须要某些机制来进行事件和指令的翻译。这个机制就是目标-动做机制。

7objc的内存管理

?? 若是您经过分配和初始化（好比[[MyClass alloc] init]）的方式来建立对象，您就拥

有这个对象，须要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也一样适用。

?? 若是您拷贝一个对象，您也拥有拷贝获得的对象，须要负责该对象的释放。

?? 若是您保持一个对象，您就部分拥有这个对象，须要在再也不使用时释放该对象。

反过来，

?? 若是您从其它对象那里接收到一个对象，则您不拥有该对象，也不该该释放它（这个规则有少数

的例外，在参考文档中有显式的说明）。

8 自动释放池是什么,如何工做

2. NSAutoreleasePool 就是用来作引用计数的管理工做的,这个东西通常不用你管的.

3. autorelease和release没什么区别,只是引用计数减一的时机不一样而已,autorelease会在对象的使用真正结束的时候才作引用计数减一.

9类工厂方法是什么

类工厂方法的实现是为了向客户提供方便，它们将分配和初始化合在一个步骤中，返回被建立的对象，并

进行自动释放处理。这些方法的形式是+ (type)className...（其中 className不包括任何前缀）。

工厂方法可能不只仅为了方便使用。它们不但能够将分配和初始化合在一块儿，还能够为初始化过程提供对

象的分配信息。

类工厂方法的另外一个目的是使类（好比NSWorkspace）提供单件实例。虽然init...方法能够确认一

个类在每次程序运行过程只存在一个实例，但它须要首先分配一个“生的”实例，而后还必须释放该实例。

工厂方法则能够避免为可能没有用的对象盲目分配内存。

10单件实例是什么

Foundation 和 Application Kit 框架中的一些类只容许建立单件对象，即这些类在当前进程中的惟一实例。举例来讲，NSFileManager 和NSWorkspace 类在使用时都是基于进程进行单件对象的实例化。当向这些类请求实例的时候，它们会向您传递单一实例的一个引用，若是该实例还不存在，则首先进行实例的分配和初始化。单件对象充当控制中心的角色，负责指引或协调类的各类服务。若是类在概念上只有一个实例（好比

NSWorkspace），就应该产生一个单件实例，而不是多个实例；若是未来某一天可能有多个实例，您可

以使用单件实例机制，而不是工厂方法或函数。

11动态绑定

—在运行时肯定要调用的方法

特别是当消息的接收者是动态类型已经肯定的对象时，动态绑定就会例行而透明地发生。

12obj-c的优缺点

objc优势：

1) Cateogies

2) Posing

3) 动态识别

4) 指标计算

5）弹性讯息传递

6) 不是一个过分复杂的 C 衍生语言

7) Objective-C 与 C++ 可混合编程

缺点:

1) 不支援命名空间

2) 不支持运算符重载

3）不支持多重继承

4）使用动态运行时类型，全部的方法都是函数调用，因此不少编译时优化方法都用不到。（如内联函数等），性能低劣。

13sprintf,strcpy,memcpy使用上有什么要注意的地方

strcpy是一个字符串拷贝的函数，它的函数原型为strcpy(char *dst, c*****t char *src);

将 src开始的一段字符串拷贝到dst开始的内存中去，结束的标志符号为'\0'，因为拷贝的长度不是由咱们本身控制的，因此这个字符串拷贝很容易出错。具有字符串拷贝功能的函数有memcpy，这是一个内存拷贝函数，它的函数原型为memcpy(char *dst, c*****t char* src, unsigned int len);

将长度为len的一段内存，从src拷贝到dst中去，这个函数的长度可控。可是会有内存叠加的问题。

sprintf是格式化函数。将一段数据经过特定的格式，格式化到一个字符串缓冲区中去。sprintf格式化的函数的长度不可控，有可能格式化后的字符串会超出缓冲区的大小，形成溢出。

14答案是：

a) int a; // An integer

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

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

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

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

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

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

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

15.readwrite，readonly，assign，retain，copy，nonatomic属性的做用

@property是一个属性访问声明，扩号内支持如下几个属性：

1，getter=getterName，setter=setterName，设置setter与getter的方法名

2，readwrite,readonly，设置可供访问级别

2，assign，setter方法直接赋值，不进行任何retain操做，为了解决原类型与环循引用问题

3，retain，setter方法对参数进行release旧值再retain新值，全部实现都是这个顺序(CC上有相关资料)

4，copy，setter方法进行Copy操做，与retain处理流程同样，先旧值release，再Copy出新的对象，retainCount为1。这是为了减小对上下文的依赖而引入的机制。

copy是在你不但愿a和b共享一块内存时会使用到。a和b各自有本身的内存。

5，nonatomic，非原子性访问，不加同步，多线程并发访问会提升性能。注意，若是不加此属性，则默认是两个访问方法都为原子型事务访问。锁被加到所属对象实例级(我是这么理解的...)。

atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操做。在多线程环境下，原子操做是必要的，不然有可能引发错误的结果。加了atomic，setter函数会变成下面这样：

16何时用delegate，何时用Notification？答：delegate针对one-to-one关系，而且reciever能够返回值给sender，notification 能够针对one-to-one/many/none,reciever没法返回值给sender.因此，delegate用于sender但愿接受到 reciever的某个功能反馈值，notification用于通知多个object某个事件。

17什么是KVC和KVO？答：KVC(Key-Value-Coding)内部的实现：一个对象在调用setValue的时候，（1）首先根据方法名找到运行方法的时候所须要的环境参数。（2）他会从本身isa指针结合环境参数，找到具体的方法实现的接口。（3）再直接查找得来的具体的方法实现。KVO（Key-Value- Observing）：当观察者为一个对象的属性进行了注册，被观察对象的isa指针被修改的时候，isa指针就会指向一个中间类，而不是真实的类。因此 isa指针其实不须要指向实例对象真实的类。因此咱们的程序最好不要依赖于isa指针。在调用类的方法的时候，最好要明确对象实例的类名

18ViewController 的 loadView, viewDidLoad, viewDidUnload 分别是在何时调用的？在自定义ViewController的时候这几个函数里面应该作什么工做？答：viewDidLoad在view 从nib文件初始化时调用，loadView在controller的view为nil时调用。此方法在编程实现view时调用,view 控制器默认会注册memory warning notification,当view controller的任何view 没有用的时候，viewDidUnload会被调用，在这里实现将retain 的view release,若是是retain的IBOutlet view 属性则不要在这里release,IBOutlet会负责release 。

"NSMutableString *"这个数据类型则是表明"NSMutableString"对象自己，这二者是有区别的。

而NSString只是对象的指针而已。

面向过程就是分析出解决问题所须要的步骤，而后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就能够了。

面向对象是把构成问题事务分解成各个对象，创建对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。；

20类别的做用

类别主要有3个做用：

(1)将类的实现分散到多个不一样文件或多个不一样框架中。

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

(3)向对象添加非正式协议。

类别的局限性

有两方面局限性：

(1)没法向类中添加新的实例变量，类别没有位置容纳实例变量。

(2)名称冲突，即当类别中的方法与原始类方法名称冲突时，类别具备更高的优先级。类别方法将彻底取代初始方法从而没法再使用初始方法。

没法添加实例变量的局限能够使用字典对象解决

21关键字volatile有什么含意?并给出三个不一样的例子：

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到

这个变量时必须每次都当心地从新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

• 并行设备的硬件寄存器（如：状态寄存器）

• 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

• 多线程应用中被几个任务共享的变量

• 一个参数既能够是const还能够是volatile吗？解释为何。

• 一个指针能够是volatile 吗？解释为何。

下面是答案：

• 是的。一个例子是只读的状态寄存器。它是volatile由于它可能被意想不到地改变。它是const由于程序不该该试图去修改它。

• 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

22@synthesize 是系统自动生成getter和setter属性声明

@dynamic 是开发者自已提供相应的属性声明

@dynamic 意思是由开发人员提供相应的代码：对于只读属性须要提供 setter，对于读写属性须要提供 setter 和 getter。@synthesize 意思是，除非开发人员已经作了，不然由编译器生成相应的代码，以知足属性声明。

查阅了一些资料肯定@dynamic的意思是告诉编译器,属性的获取与赋值方法由用户本身实现, 不自动生成。

23Difference between shallow copy and deep copy?
浅复制和深复制的区别？
答案：浅层复制：只复制指向对象的指针，而不复制引用对象自己。
深层复制：复制引用对象自己。
意思就是说我有个A对象，复制一份后获得A_copy对象后，对于浅复制来讲，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象自己资源
仍是只有一份，那若是咱们对A_copy执行了修改操做,那么发现A引用的对象一样被修改，这其实违背了咱们复制拷贝的一个思想。深复制就好理解了,内存中存在了
两份独立对象自己。
用网上一哥们通俗的话将就是：
浅复制比如你和你的影子，你完蛋，你的影子也完蛋
深复制比如你和你的克隆人，你完蛋，你的克隆人还活着。

24What is advantage of categories? What is difference between implementing a category and inheritance?
类别的做用？继承和类别在实现中有何区别？
答案：category 能够在不获悉，不改变原来代码的状况下往里面添加新的方法，只能添加，不能删除修改。
而且若是类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，由于类别具备更高的优先级。
类别主要有3个做用：
(1)将类的实现分散到多个不一样文件或多个不一样框架中。
(2)建立对私有方法的前向引用。
(3)向对象添加非正式协议。
继承能够增长，修改或者删除方法，而且能够增长属性。

25.Difference between categories and extensions?
类别和类扩展的区别。
答案：category和extensions的不一样在于后者能够添加属性。另外后者添加的方法是必需要实现的。
extensions能够认为是一个私有的Category。

26.Difference between protocol in objective c and interfaces in java?
oc中的协议和java中的接口概念有何不一样？
答案：OC中的代理有2层含义，官方定义为 formal和informal protocol。前者和Java接口同样。
informal protocol中的方法属于设计模式考虑范畴，不是必须实现的，可是若是有实现，就会改变类的属性。
其实关于正式协议，类别和非正式协议我很早前学习的时候大体看过，也写在了学习教程里
“非正式协议概念其实就是类别的另外一种表达方式“这里有一些你可能但愿实现的方法，你能够使用他们更好的完成工做”。
这个意思是，这些是可选的。好比我门要一个更好的方法，咱们就会申明一个这样的类别去实现。而后你在后期能够直接使用这些更好的方法。
这么看，总以为类别这玩意儿有点像协议的可选协议。"
如今来看，其实protocal已经开始对二者都统一和规范起来操做，由于资料中说“非正式协议使用interface修饰“，
如今咱们看到协议中两个修饰词：“必须实现(@requied)”和“可选实现(@optional)”。

26What are KVO and KVC?
答案：kvc:键 - 值编码是一种间接访问对象的属性使用字符串来标识属性，而不是经过调用存取方法，直接或经过实例变量访问的机制。
不少状况下能够简化程序代码。apple文档其实给了一个很好的例子。
kvo:键值观察机制，他提供了观察某一属性变化的方法，极大的简化了代码。
具体用看到嗯哼用到过的一个地方是对于按钮点击变化状态的的监控。
好比我自定义的一个button
[cpp]
[self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];
#pragma mark KVO
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if ([keyPath isEqualToString:@"highlighted"] ) {
        [self setNeedsDisplay];
    }
}

对于系统是根据keypath去取的到相应的值发生改变，理论上来讲是和kvc机制的道理是同样的。
对于kvc机制如何经过key寻找到value：
“当经过KVC调用对象时，好比：[self valueForKey:@”someKey”]时，程序会自动试图经过几种不一样的方式解析这个调用。首先查找对象是否带有 someKey 这个方法，若是没找到，会继续查找对象是否带有someKey这个实例变量（iVar），若是尚未找到，程序会继续试图调用 -(id) valueForUndefinedKey:这个方法。若是这个方法仍是没有被实现的话，程序会抛出一个NSUndefinedKeyException异常错误。
(cocoachina.com注：Key-Value Coding查找方法的时候，不只仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及_getsomeKey这几种形式。同时，查找实例变量的时候也会不只仅查找someKey这个变量，也会查找_someKey这个变量是否存在。）
设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象可以在错误发生前，有最后的机会响应这个请求。这样作有不少好处，下面的两个例子说明了这样作的好处。“
来至cocoa，这个说法应该挺有道理。
由于咱们知道button倒是存在一个highlighted实例变量.所以为什么上面咱们只是add一个相关的keypath就好了，

27What is purpose of delegates?
代理的做用？
答案：代理的目的是改变或传递控制链。容许一个类在某些特定时刻通知到其余类，而不须要获取到那些类的指针。能够减小框架复杂度。
另一点，代理能够理解为java中的回调监听机制的一种相似。

28What are mutable and immutable types in Objective C?
oc中可修改和不能够修改类型。
答案：可修改不可修改的集合类。这个我我的简单理解就是可动态添加修改和不可动态添加修改同样。
好比NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者能够添加等，能够动态申请新的内存空间

29When we call objective c is runtime language what does it mean?
咱们说的oc是动态运行时语言是什么意思？
答案：多态。主要是将数据类型的肯定由编译时，推迟到了运行时。
这个问题其实浅涉及到两个概念，运行时和多态。
简单来讲，运行时机制使咱们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。
多态：不一样对象以本身的方式响应相同的消息的能力叫作多态。意思就是假设生物类（life）都用有一个相同的方法-eat;
那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，可是调用是咱们只需调用各自的eat方法。
也就是不一样的对象以本身的方式响应了相同的消息（响应了eat这个选择器）。
所以也能够说，运行时机制是多态的基础？~~~

30what is difference between NSNotification and protocol?
通知和协议的不一样之处？
答案：协议有控制链(has-a)的关系，通知没有。
首先我一开始也不太明白，什么叫控制链（专业术语了~）。可是简单分析下通知和代理的行为模式，咱们大体能够有本身的理解
简单来讲，通知的话，它能够一对多，一条消息能够发送给多个消息接受者。
代理按咱们的理解，到不是直接说不能一对多，好比咱们知道的明星经济代理人，不少时候一个经济人负责好几个明星的事务。
只是对于不一样明星间，代理的事物对象都是不同的，一一对应，不可能说明天要处理A明星要一个发布会，代理人发出处理发布会的消息后，别称B的
发布会了。可是通知就不同，他只关心发出通知，而不关心多少接收到感兴趣要处理。
所以控制链（has-a从英语单词大体能够看出，单一拥有和可控制的对应关系。

31What is push notification?
什么是推送消息？
答案：太简单，不做答~~~~~~~~~~
这是cocoa上的答案。
其实到不是说太简单，只是太泛泛的一个概念的东西。就比如说，什么是人。
推送通知更是一种技术。
简单点就是客户端获取资源的一种手段。
普通状况下，都是客户端主动的pull。
推送则是服务器端主动push。

32.Polymorphism？
关于多态性
答案：多态，子类指针能够赋值给父类。
这个题目其实能够出到一切面向对象语言中，
所以关于多态，继承和封装基本最好都有个自我意识的理解，也并不是必定要把书上资料上写的能背出来。
最重要的是转化成自我理解。

What is responder chain?
说说响应链
答案：事件响应链。包括点击事件，画面刷新事件等。在视图栈内从上至下，或者从下之上传播。
能够说点事件的分发，传递以及处理。具体能够去看下touch事件这块。由于问的太抽象化了
严重怀疑题目出到越后面就越笼统。

34Difference between frame and bounds?
frame和bounds有什么不一样？
答案:frame指的是：该view在父view坐标系统中的位置和大小。（参照点是父亲的坐标系统）
bounds指的是：该view在自己坐标系统中的位置和大小。（参照点是自己坐标系统）

.Difference between method and selector?
方法和选择器有何不一样？
答案：selector是一个方法的名字，method是一个组合体，包含了名字和实现.

36NSOperation queue?
答案：存放NSOperation的集合类。
操做和操做队列，基本能够当作java中的线程和线程池的概念。用于处理ios多线程开发的问题。
网上部分资料提到一点是，虽然是queue，可是却并非带有队列的概念，放入的操做并不是是按照严格的先进现出。
这边又有个疑点是，对于队列来讲，先进先出的概念是Afunc添加进队列，Bfunc紧跟着也进入队列，Afunc先执行这个是必然的，
可是Bfunc是等Afunc彻底操做完之后，B才开始启动而且执行，所以队列的概念离乱上有点违背了多线程处理这个概念。
可是转念一想其实能够参考银行的取票和叫号系统。
所以对于A比B先排队取票可是B率先执行完操做，咱们亦然能够感性认为这仍是一个队列。
可是后来看到一票关于这操做队列话题的文章，其中有一句提到
“由于两个操做提交的时间间隔很近，线程池中的线程，谁先启动是不定的。”
瞬间以为这个queue名字有点忽悠人了，还不如pool~
综合一点，咱们知道他能够比较大的用处在于能够帮组多线程编程就行了。

37What is lazy loading?
答案：懒汉模式，只在用到的时候才去初始化。
也能够理解成延时加载。
我以为最好也最简单的一个列子就是tableView中图片的加载显示了。
一个延时载，避免内存太高，一个异步加载，避免线程堵塞。

38Can we use two tableview controllers on one viewcontroller?
是否在一个视图控制器中嵌入两个tableview控制器？
答案：一个视图控制只提供了一个View视图，理论上一个tableViewController也不能放吧，
只能说能够嵌入一个tableview视图。固然，题目自己也有歧义，若是不是咱们定性思惟认为的UIViewController，
而是宏观的表示视图控制者，那咱们却是能够把其当作一个视图控制者，它能够控制多个视图控制器，好比TabbarController
那样的感受。

39Can we use one tableview with two different datasources? How you will achieve this?
一个tableView是否能够关联两个不一样的数据源？你会怎么处理？
答案：首先咱们从代码来看，数据源如何关联上的，实际上是在数据源关联的代理方法里实现的。
所以咱们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据本身的须要去设置如相关的数据源。
所以，我以为能够设置多个数据源啊，可是有个问题是，你这是想干吗呢？想让列表如何显示，不一样的数据源分区块显示？

40id、nil表明什么？

id和void *并不是彻底同样。在上面的代码中，id是指向struct objc_object的一个指针，这个意思基本上是说，id是一个指向任何一个继承了Object（或者NSObject）类的对象。须要注意的是id是一个指针，因此你在使用id的时候不须要加星号。好比id foo=nil定义了一个nil指针，这个指针指向NSObject的一个任意子类。而id *foo=nil则定义了一个指针，这个指针指向另外一个指针，被指向的这个指针指向NSObject的一个子类。

nil和C语言的NULL相同，在objc/objc.h中定义。nil表示一个Objctive-C对象，这个对象的指针指向空（没有东西就是空）。

首字母大写的Nil和nil有一点不同，Nil定义一个指向空的类（是Class，而不是对象）。

SEL是“selector”的一个类型，表示一个方法的名字

Method（咱们常说的方法）表示一种类型，这种类型与selector和实现(implementation)相关

IMP定义为 id (*IMP) (id, SEL, …)。这样说来， IMP是一个指向函数的指针，这个被指向的函数包括id(“self”指针)，调用的SEL（方法名），再加上一些其余参数.说白了IMP就是实现方法。

41层和UIView的区别是什么？

答：二者最大的区别是,图层不会直接渲染到屏幕上，UIView是iOS系统中界面元素的基础，全部的界面元素都是继承自它。它自己彻底是由CoreAnimation来实现的。它真正的绘图部分，是由一个CALayer类来管理。UIView自己更像是一个CALayer的管理器。一个UIView上能够有n个CALayer，每一个layer显示一种东西，加强UIView的展示能力。

42GCD为Grand Central Dispatch的缩写。　　Grand Central Dispatch (GCD)是Apple开发的一个多核编程的较新的解决方法。在Mac OS X 10.6雪豹中首次推出，并在最近引入到了iOS4.0。　　GCD是一个替代诸如NSThread等技术的很高效和强大的技术。GCD彻底能够处理诸如数据锁定和资源泄漏等复杂的异步编程问题。　

　GCD能够完成不少事情，可是这里仅关注在iOS应用中实现多线程所需的一些基础知识。　　在开始以前，须要理解是要提供给GCD队列的是代码块，用于在系统或者用户建立的的队列上调度运行。　　声明一个队列　　

以下会返回一个用户建立的队列：

　　dispatch_queue_t myQueue = dispatch_queue_create("com.iphonedevblog.post", NULL);其中，第一个参数是标识队列的，第二个参数是用来定义队列的参数（目前不支持，所以传入NULL）。　

执行一个队列　

　以下会异步执行传入的代码：　

　dispatch_async(myQueue, ^{ [self doSomething]; });其中，首先传入以前建立的队列，而后提供由队列运行的代码块。　　

声明并执行一个队列　　

若是不须要保留要运行的队列的引用，能够经过以下代码实现以前的功能：　　dispatch_async(dispatch_queue_create ("com.iphonedevblog.post", NULL), ^{ [self doSomething]; });　　若是须要暂停一个队列，能够调用以下代码。暂停一个队列会阻止和该队列相关的全部代码运行。　　dispatch_suspend(myQueue);暂停一个队列 　

若是暂停一个队列不要忘记恢复。暂停和恢复的操做和内存管理中的retain和release相似。调用dispatch_suspend会增长暂停计数，而dispatch_resume则会减小。队列只有在暂停计数变成零的状况下才开始运行。dispatch_resume(myQueue);恢复一个队列　　　从队列中在主线程运行代码　　有些操做没法在异步队列运行，所以必须在主线程（每一个应用都有一个）上运行。UI绘图以及任何对NSNotificationCenter的调用必须在主线程长进行。在另外一个队列中访问主线程并运行代码的示例以下：　　dispatch_sync(dispatch_get_main_queue(), ^{ [self dismissLoginWindow]; });注意，dispatch_suspend （以及dispatch_resume）在主线程上不起做用。

使用GCD，可让你的程序不会失去响应. 多线程不容易使用，用了GCD，会让它变得简单。你无需专门进行线程管理, 很棒！

dispatch_queue_t t1=dispatch_queue_create("1", NULL);

dispatch_queue_t t2=dispatch_queue_create("2", NULL);

dispatch_async(t1, ^{

[self print1];

});

dispatch_async(t2, ^{

[self print2];

});

43Provider是指某个iPhone软件的Push服务器，这篇文章我将使用.net做为Provider。
APNS 是Apple Push Notification Service（Apple Push服务器）的缩写，是苹果的服务器。

上图能够分为三个阶段。

第一阶段：.net应用程序把要发送的消息、目的iPhone的标识打包，发给APNS。
第二阶段：APNS在自身的已注册Push服务的iPhone列表中，查找有相应标识的iPhone，并把消息发到iPhone。
第三阶段：iPhone把发来的消息传递给相应的应用程序，而且按照设定弹出Push通知。

http://blog.csdn.net/zhuqilin0/article/details/6527113 //消息推送机制

看内存泄露时候：在搜索中搜索run 找到Run Static Snalyzer .

44.可扩展标记语言extensible markup language;XML

2.用于标记电子文件使其具备结构性的标记语言，能够用来标记数据、定义数据类型，是一种容许用户对本身的标记语言进行定义的源语言。

3，数据库提供了更强有力的数据存储和分析能力，例如：数据索引、排序、查找、相关一致性等，XML仅仅是存储数据。

4.XML与HTML的设计区别是：XML的核心是数据，其重点是数据的内容。而HTML 被设计用来显示数据，其重点是数据的显示。

5.XML和HTML语法区别：HTML的标记不是全部的都须要成对出现，XML则要求全部的标记必须成对出现；HTML标记不区分大小写，XML则大小敏感,即区分大小写。

结合

　　XML的简单使其易于在任何应用程序中读写数据，这使XML很快成为数据交换的惟一公共语言，虽然不一样的应用软件也支持其它的数据交换格式，但不久以后他们都将支持XML，那就意味着程序能够更容易的与Windows,Mac OS,Linux以及其余平台下产生的信息结合，而后能够很容易加载XML数据到程序中并分析他，并以XML格式输出结果。

　　XML去掉了以前令许多开发人员头疼的SGML（标准通用标记语言）的随意语法。在XML中，采用了以下的语法：

　　1 任何的起始标签都必须有一个结束标签。

　　2 能够采用另外一种简化语法，能够在一个标签中同时表示起始和结束标签。这种语法是在大于符号以前紧跟一个斜线（/），例如<tag/ >。XML解析器会将其翻译成<tag></tag>。

　　3 标签必须按合适的顺序进行嵌套，因此结束标签必须按镜像顺序匹配起始标签，例如this is a samplestring。这比如是将起始和结束标签看做是数学中的左右括号：在没有关闭全部的内部括号以前，是不能关闭外面的括号的。

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

　　5 全部的特性都必须在值的周围加上双引号。

45union u

{

　double a;

　int b;

};

union u2

{

　char a[13];

　int b;

};

union u3

{

　char a[13];

　char b;

};

cout<<sizeof(u)<<endl; // 8

cout<<sizeof(u2)<<endl; // 16

cout<<sizeof(u3)<<endl; // 13

　　都知道union的大小取决于它全部的成员中，占用空间最大的一个成员的大小。因此对于u来讲，大小就是最大的double类型成员a了，因此 sizeof(u)=sizeof(double)=8。可是对于u2和u3，最大的空间都是char[13]类型的数组，为何u3的大小是13，而 u2是16呢？关键在于u2中的成员int b。因为int类型成员的存在，使u2的对齐方式变成4，也就是说，u2的大小必须在4的对界上，因此占用的空间变成了16（最接近13的对界）。 struct s1

{

　char a;

　double b;

　int c;

　char d;

};

struct s2

{

　char a;

　char b;

　int c;

　double d;

};

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

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

　　一样是两个char类型，一个int类型，一个double类型，可是由于对界问题，致使他们的大小不一样。计算结构体大小能够采用元素摆放法，我举例子说明一下：首先，CPU判断结构体的对界，根据上一节的结论，s1和s2的对界都取最大的元素类型，也就是double类型的对界8。而后开始摆放每一个元素。

　　对于s1，首先把a放到8的对界，假定是0，此时下一个空闲的地址是1，可是下一个元素d是double类型，要放到8的对界上，离1最接近的地址是8了，因此d被放在了8，此时下一个空闲地址变成了16，下一个元素c的对界是4，16能够知足，因此c放在了16，此时下一个空闲地址变成了20，下一个元素d须要对界1，也正好落在对界上，因此d放在了20，结构体在地址21处结束。因为s1的大小须要是8的倍数，因此21- 23的空间被保留，s1的大小变成了24。

　　对于s2，首先把a放到8的对界，假定是0，此时下一个空闲地址是1，下一个元素的对界也是1，因此b摆放在1，下一个空闲地址变成了2；下一个元素c的对界是4，因此取离2最近的地址4摆放c，下一个空闲地址变成了8，下一个元素d的对界是 8，因此d摆放在8，全部元素摆放完毕，结构体在15处结束，占用总空间为16，正好是8的倍数。

46ASIDownloadCache 设置下载缓存

它对Get请求的响应数据进行缓存（被缓存的数据必需是成功的200请求）：

[ASIHTTPRequest setDefaultCache:[ASIDownloadCache sharedCache]];

当设置缓存策略后，全部的请求都被自动的缓存起来。

另外，若是仅仅但愿某次请求使用缓存操做，也能够这样使用：

ASIHTTPRequest *request = [ASIHTTPRequest requestWithURL:url];

[request setDownloadCache:[ASIDownloadCache sharedCache]];

缓存存储方式

你能够设置缓存的数据须要保存多长时间，ASIHTTPRequest提供了两种策略：

a，ASICacheForSessionDurationCacheStoragePolicy，默认策略，基于session的缓存数据存储。当下次运行或[ASIHTTPRequest clearSession]时，缓存将失效。

b，ASICachePermanentlyCacheStoragePolicy，把缓存数据永久保存在本地，

如：

ASIHTTPRequest *request = [ ASIHTTPRequest requestWithURL:url ];

[ request setCacheStoragePolicy:ASICachePermanentlyCacheStoragePolicy ];

47HTTP协议详解

HTTP是一个属于应用层的面向对象的协议，因为其简捷、快速的方式，适用于分布式超媒体信息系统。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工做正在进行之中。

http（超文本传输协议）是一个基于请求与响应模式的、无状态的、应用层的协议，常基于TCP的链接方式，HTTP1.1版本中给出一种持续链接的机制，绝大多数的Web开发，都是构建在HTTP协议之上的Web应用。
HTTP协议的主要特色可归纳以下：
1.支持客户/服务器模式。
2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法经常使用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不一样。因为HTTP协议简单，使得HTTP服务器的程序规模小，于是通讯速度很快。
3.灵活：HTTP容许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.无链接：无链接的含义是限制每次链接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开链接。采用这种方式能够节省传输时间。
5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺乏状态意味着若是后续处理须要前面的信息，则它必须重传，这样可能致使每次链接传送的数据量增大。另外一方面，在服务器不须要先前信息时它的应答就较快。

48URL

HTTP URL (URL是一种特殊类型的URI是他的子类，包含了用于查找某个资源的足够的信息)的格式以下：
http://host[":"port][abs_path]
http表示要经过HTTP协议来定位网络资源；host表示合法的Internet主机域名或者IP地址；port指定一个端口号，为空则使用缺省端口80；abs_path指定请求资源的URI；若是URL中没有给出abs_path，那么当它做为请求URI时，必须以“/”的形式给出，一般这个工做浏览器自动帮咱们完成。

49TCP/UDP区别联系

TCP---传输控制协议,提供的是面向链接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间创建一个TCP链接，以后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另外一端。

UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，可是并不能保证它们能到达目的地。因为UDP在传输数据报前不用在客户和服务器之间创建一个链接，且没有超时重发等机制，故而传输速度很快

TCP（Transmission Control Protocol，传输控制协议）是基于链接的协议，也就是说，在正式收发数据前，必须和对方创建可靠的链接。一个TCP链接必需要通过三次“对话”才能创建起来，咱们来看看这三次对话的简单过程：1.主机A向主机B发出链接请求数据包；2.主机B向主机A发送赞成链接和要求同步（同步就是两台主机一个在发送，一个在接收，协调工做）的数据包；3.主机A再发出一个数据包确认主机B的要求同步：“我如今就发，你接着吧！”，这是第三次对话。三次“对话”的目的是使数据包的发送和接收同步，通过三次“对话”以后，主机A才向主机B正式发送数据。

UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非链接的协议，它不与对方创建链接，而是直接就把数据包发送过去！ UDP适用于一次只传送少许数据、对可靠性要求不高的应用环境。

tcp协议和udp协议的差异

是否链接面向链接面向非链接

传输可靠性可靠不可靠

应用场合传输大量数据少许数据

速度慢快

50socket链接和http链接的区别

简单说，你浏览的网页（网址以http://开头)都是http协议传输到你的浏览器的, 而http是基于socket之上的。socket是一套完成tcp，udp协议的接口。

HTTP协议：简单对象访问协议，对应于应用层，HTTP协议是基于TCP链接的

tcp协议：对应于传输层

ip协议：对应于网络层
TCP/IP是传输层协议，主要解决数据如何在网络中传输；而HTTP是应用层协议，主要解决如何包装数据。

Socket是对TCP/IP协议的封装，Socket自己并非协议，而是一个调用接口（API），经过Socket，咱们才能使用TCP/IP协议。

http链接：http链接就是所谓的短链接，即客户端向服务器端发送一次请求，服务器端响应后链接即会断掉；

socket链接：socket链接就是所谓的长链接，理论上客户端和服务器端一旦创建起链接将不会主动断掉；可是因为各类环境因素可能会是链接断开，好比说：服务器端或客户端主机down了，网络故障，或者二者之间长时间没有数据传输，网络防火墙可能会断开该链接以释放网络资源。因此当一个socket链接中没有数据的传输，那么为了维持链接须要发送心跳消息~~具体心跳消息格式是开发者本身定义的

咱们已经知道网络中的进程是经过socket来通讯的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，均可以用“打开open –> 读写write/read –> 关闭close”模式来操做。个人理解就是Socket就是该模式的一个实现，socket便是一种特殊的文件，一些socket函数就是对其进行的操做（读/写IO、打开、关闭），这些函数咱们在后面进行介绍。咱们在传输数据时，能够只使用（传输层）TCP/IP协议，可是那样的话，若是没有应用层，便没法识别数据内容，若是想要使传输的数据有意义，则必须使用到应用层协议，应用层协议有不少，好比HTTP、FTP、TELNET等，也能够本身定义应用层协议。WEB使用HTTP协议做应用层协议，以封装HTTP文本信息，而后使用TCP/IP作传输层协议将它发到网络上。
1)Socket是一个针对TCP和UDP编程的接口，你能够借助它创建TCP链接等等。而TCP和UDP协议属于传输层。
而http是个应用层的协议，它实际上也创建在TCP协议之上。

(HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通讯的能力。)

2）Socket是对TCP/IP协议的封装，Socket自己并非协议，而是一个调用接口（API），经过Socket，咱们才能使用TCP/IP协议。Socket的出现只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而造成了咱们知道的一些最基本的函数接口。

51什么是TCP链接的三次握手

第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时本身也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

握手过程当中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP链接一旦创建，在通讯双方中的任何一方主动关闭链接以前，TCP 链接都将被一直保持下去。断开链接时服务器和客户端都可以主动发起断开TCP链接的请求，断开过程须要通过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终肯定断开）

52利用Socket创建网络链接的步骤

创建Socket链接至少须要一对套接字，其中一个运行于客户端，称为ClientSocket ，另外一个运行于服务器端，称为ServerSocket 。

套接字之间的链接过程分为三个步骤：服务器监听，客户端请求，链接确认。

1。服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待链接的状态，实时监控网络状态，等待客户端的链接请求。

2。客户端请求：指客户端的套接字提出链接请求，要链接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要链接的服务器的套接字，指出服务器端套接字的地址和端口号，而后就向服务器端套接字提出链接请求。

3。链接确认：当服务器端套接字监听到或者说接收到客户端套接字的链接请求时，就响应客户端套接字的请求，创建一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式创建链接。而服务器端套接字继续处于监听状态，继续接收其余客户端套接字的链接请求。

53进程与线程

进程（process）是一块包含了某些资源的内存区域。操做系统利用进程把它的工做划分为一些功能单元。

进程中所包含的一个或多个执行单元称为线程（thread）。进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。

一般在一个进程中能够包含若干个线程，它们能够利用进程所拥有的资源。

在引入线程的操做系统中，一般都是把进程做为分配资源的基本单位，而把线程做为独立运行和独立调度的基本单位。

因为线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提升系统内多个程序间并发执行的程度。

线程只能归属于一个进程而且它只能访问该进程所拥有的资源。当操做系统建立一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。应用程序（application）是由一个或多个相互协做的进程组成的。

另外，进程在执行过程当中拥有独立的内存单元，而多个线程共享内存，从而极大地提升了程序的运行效率。
线程在执行过程当中与进程仍是有区别的。每一个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。可是线程不可以独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分能够同时执行。但操做系统并无将多个线程看作多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

进程是具备必定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程本身基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),可是它可与同属一个进程的其余的线程共享进程所拥有的所有资源.
一个线程能够建立和撤销另外一个线程;同一个进程中的多个线程之间能够并发执行.

多线程编程是防止主线程堵塞，增长运行效率等等的最佳方法。而原始的多线程方法存在不少的毛病，包括线程锁死等。在Cocoa中，Apple提供了NSOperation这个类，提供了一个优秀的多线程编程方法。

本次介绍NSOperation的子集，简易方法的NSInvocationOperation：

一个NSOperationQueue 操做队列，就至关于一个线程管理器，而非一个线程。由于你能够设置这个线程管理器内能够并行运行的的线程数量等等

55oc语法里的@perpoerty不用写@synzhesize了，自动填充了。而且的_name;

写方法时候不用提早声明。llvm 全局方法便利。

枚举类型。enum hello:Integer{ } 冒号后面直接能够跟类型，之前是：

enum hello{} 后面在指定为Integer .

桥接。ARC 自动release retain 的时候 CFString CFArray . Core Fountion. 加上桥接_brige 才能区分CFString 和NSString 而如今自动区分了，叫固定桥接。

下拉刷新封装好了。

UICollectionViewController. 能够把表格分红多列。

Social Framework(社交集成)

UIActivityViewController来询问用户的社交行为

缓存：就是存放在临时文件里，好比新浪微博请求的数据，和图片，下次请求看这里有没有值。

56Singleton（单例模式），也叫单子模式，是一种经常使用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。

代码以下：

static ClassA *classA = nil；//静态的该类的实例

+ (ClassA *)sharedManager

｛

@synchronized(self) {

if (!classA) {

classA = [[super allocWithZone:NULL]init];

}

return classA;

}

｝

+ (id)allocWithZone:(NSZone *)zone {

return [[self sharedManager] retain];

}

- (id)copyWithZone:(NSZone *)zone {

return self;

}

- (id)retain {

return self;

}

- (NSUIntger)retainCount {

return NSUIntgerMax;

}

- (oneway void)release {

}

- (id)autorelease {

return self;

}

-(void)dealloc{

}

57请写一个C函数，若处理器是Big_endian的，则返回0；如果Little_endian的，则返回1 int checkCPU( ) {

{

union w

{

int a;

char b;

} c;

c.a = 1;

return (c.b ==1);

}

剖析：嵌入式系统开发者应该对Little-endian和Big-endian模式很是了解。采用Little-endian模式的CPU对操做数的存放方式是从低字节到高字节， Big-endian 模式的CPU对操做数的存放方式是从高字节到低字节。在弄清楚这个以前要弄清楚这个问题：字节从右到坐为从高到低! 假设从地址0x4000开始存放: 0x12345678,是也个32位四个字节的数据，最高字节是0x12,最低字节是0x78：在Little-endian模式CPU内存中的存放方式为： (高字节在高地址, 低字节在低地址)

内存地址0x4000 0x4001 0x4002 0x4003

存放内容 0x78 0x56 0x34 0x12

大端机则相反。

有的处理器系统采用了小端方式进行数据存放，如Intel的奔腾。有的处理器系统采用了大端方式进行数据存放，如IBM半导体和Freescale的PowerPC处理器。不只对于处理器，一些外设的设计中也存在着使用大端或者小端进行数据存放的选择。所以在一个处理器系统中，有可能存在大端和小端模式同时存在的现象。这一现象为系统的软硬件设计带来了不小的麻烦，这要求系统设计工程师，必须深刻理解大端和小端模式的差异。大端与小端模式的差异体如今一个处理器的寄存器，指令集，系统总线等各个层次中。联合体union的存放顺序是全部成员都从低地址开始存放的。以上是网上的原文。让咱们看看在ARM处理器上union是如何存储的呢? 地址A ---------------- |A |A+1 |A+2 |A+3 |int a; | | | | -------------------- |A |char b; | | --------- 若是是小端如何存储c.a的呢？

地址A -----------

------------------- |A |A+1 |A+2 |A+3 | int a;

|0x01 |0x00 |0x00 |0x00 | ------------------------------------- |A |char b; | | ---------

若是是大端如何存储c.a的呢？

地址A ---------------------

--------- |A |A+1 |A+2 |A+3 |int a; |0x00 |0x00 |0x00 |0x01 | ------------------------------------------ |A |char b; | | --------- 如今知道为何c.b==0的话是大端，c.b==1的话就是小端了吧。

堆和栈上的指针

指针所指向的这块内存是在哪里分配的,在堆上称为堆上的指针,在栈上为栈上的指针.

在堆上的指针,能够保存在全局数据结构中,供不一样函数使用访问同一块内存.

在栈上的指针,在函数退出后,该内存即不可访问.

59什么是指针的释放?

具体来讲包括两个概念.

1 释放该指针指向的内存,只有堆上的内存才须要咱们手工释放,栈上不须要.

2 将该指针重定向为NULL.

60数据结构中的指针?

其实就是指向一块内存的地址,经过指针传递,可实现复杂的内存访问.

7 函数指针?

指向一块函数的入口地址.

8 指针做为函数的参数?

好比指向一个复杂数据结构的指针做为函数变量

这种方法避免整个复杂数据类型内存的压栈出栈操做,提升效率.

注意:指针自己不可变,但指针指向的数据结构能够改变.

9 指向指针的指针?

指针指向的变量是一个指针,即具体内容为一个指针的值,是一个地址.

此时指针指向的变量长度也是4位.

61指针与地址的区别?

区别:

1指针意味着已经有一个指针变量存在,他的值是一个地址,指针变量自己也存放在一个长度为四个字节的地址当中,而地址概念自己并不表明有任何变量存在.

2 指针的值,若是没有限制,一般是能够变化的,也能够指向另一个地址.

地址表示内存空间的一个位置点,他是用来赋给指针的,地址自己是没有大小概念,指针指向变量的大小,取决于地址后面存放的变量类型.

62指针与数组名的关系?

其值都是一个地址,但前者是能够移动的,后者是不可变的.

12 怎样防止指针的越界使用问题?

必须让指针指向一个有效的内存地址,

1 防止数组越界

2 防止向一块内存中拷贝过多的内容

3 防止使用空指针

4 防止改变const修改的指针

5 防止改变指向静态存储区的内容

6 防止两次释放一个指针

7 防止使用野指针.

13 指针的类型转换?

指针转换一般是指针类型和void * 类型以前进行强制转换,从而与指望或返回void指针的函数进行正确的交接.

63static有什么用途？（请至少说明两种）
            1.限制变量的做用域
            2.设置变量的存储域
            7. 引用与指针有什么区别？
            1) 引用必须被初始化，指针没必要。
            2) 引用初始化之后不能被改变，指针能够改变所指的对象。
            2) 不存在指向空值的引用，可是存在指向空值的指针。
            8. 描述实时系统的基本特性
            在特定时间内完成特定的任务，实时性与可靠性

64全局变量和局部变量在内存中是否有区别？若是有，是什么区别？
            全局变量储存在静态数据库，局部变量在堆栈
            10. 什么是平衡二叉树？
            左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1

            局部变量能够与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而
            不会用到全局变量。对于有些编译器而言，在同一个函数内能够定义多个同名的局部变
            量，好比在两个循环体内都定义一个同名的局部变量，而那个局部变量的做用域就在那
            个循环体内
            二、如何引用一个已经定义过的全局变量？
            答：extern
            能够用引用头文件的方式，也能够用extern关键字，若是用引用头文件方式来引用某个
            在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，若是你
            用extern方式引用时，假定你犯了一样的错误，那么在编译期间不会报错，而在链接期
            间报错
            三、全局变量可不能够定义在可被多个.C文件包含的头文件中？为何？
            答：能够，在不一样的C文件中以static形式来声明同名全局变量。
            能够在不一样的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋
            初值，此时链接不会出错
            四、语句for( ；1 ；)有什么问题？它是什么意思？
            答：和while(1)相同。
            五、do……while和while……do有什么区别？
            答：前一个循环一遍再判断，后一个判断之后再循环

661.IP Phone的原理是什么?
            IPV6
            2.TCP/IP通讯创建的过程怎样，端口有什么做用？
            三次握手，肯定是哪一个应用程序使用该协议
            3.1号信令和7号信令有什么区别，我国某前普遍使用的是那一种？
            4.列举5种以上的电话新业务？
            微软亚洲技术中心的面试题！！！
            1．进程和线程的差异。
            线程是指进程内的一个执行单元,也是进程内的可调度实体.
            与进程的区别:
            (1)调度：线程做为调度和分配的基本单位，进程做为拥有资源的基本单位
            (2)并发性：不只进程之间能够并发执行，同一个进程的多个线程之间也可并发执行
            (3)拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但能够访问隶属
            于进程的资源.
            (4)系统开销：在建立或撤消进程时，因为系统都要为之分配和回收资源，致使系统的开
            销明显大于建立或撤消线程时的开销。
            2.测试方法
            人工测试：我的复查、抽查和会审
            机器测试：黑盒测试和白盒测试
            2．Heap与stack的差异。
            Heap是堆，stack是栈。
            Stack的空间由操做系统自动分配/释放，Heap上的空间手动分配/释放。
            Stack空间有限，Heap是很大的自由存储区
            C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操做符。
            程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程当中函数调用时参数的
            传递也在栈上进行
            3．Windows下的内存是如何管理的？
            4．介绍.Net和.Net的安全性。
            5．客户端如何访问.Net组件实现Web Service？
            6．C/C++编译器中虚表是如何完成的？
            7．谈谈COM的线程模型。而后讨论进程内/外组件的差异。
            8．谈谈IA32下的分页机制
            小页(4K)两级分页模式，大页(4M)一级
            9．给两个变量，如何找出一个带环单链表中是什么地方出现环的？
            一个递增一，一个递增二，他们指向同一个接点时就是环出现的地方
            10．在IA32中一共有多少种办法从用户态跳到内核态？
            经过调用门，从ring3到ring0，中断从ring3到ring0，进入vm86等等
            11．若是只想让程序有一个实例运行，不能运行两个。像winamp同样，只能开一个窗
            口，怎样实现？
            用内存映射或全局原子（互斥变量）、查找窗口句柄..
            FindWindow，互斥，写标志到文件或注册表,共享内存。

67如何截取键盘的响应，让全部的‘a’变成‘b’？
            键盘钩子SetWindowsHookEx
            13．Apartment在COM中有什么用？为何要引入？
            14．存储过程是什么？有什么用？有什么优势？
            个人理解就是一堆sql的集合，能够创建很是复杂的查询，编译运行，因此运行一次后，
            之后再运行速度比单独执行SQL快不少
            15．Template有什么特色？何时用？
            16．谈谈Windows DNA结构的特色和优势。
            网络编程中设计并发服务器，使用多进程与多线程，请问有什么区别？
            1，进程：子进程是父进程的复制品。子进程得到父进程数据空间、堆和栈的复制品。
            2，线程：相对与进程而言，线程是一个更加接近与执行体的概念，它能够与同进程的其
            他线程共享数据，但拥有本身的栈空间，拥有独立的执行序列。
            二者均可以提升程序的并发度，提升程序运行效率和响应时间。
            线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程
            正相反。同时，线程适合于在SMP机器上运行，而进程则能够跨机器迁移。
            思科

682.找错题

　　试题1：

void test1()
{
　char string[10];
　char* str1 = "0123456789";
　strcpy( string, str1 );
}
　　试题2：

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

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

　　试题1字符串str1须要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会致使数组越界；

　　对试题2，若是面试者指出字符数组str1不能在数组内结束能够给3分；若是面试者指出strcpy(string, str1)调用使得从str1[url=]内存[/url]起复制到string内存起所复制的字节数具备不肯定性能够给7分，在此基础上指出库函数strcpy工做方式的给10分；

　　对试题3，if(strlen(str1) <= 10)应改成if(strlen(str1) < 10)，由于strlen的结果未统计’\0’所占用的1个字节。

　　剖析：

　　考查对基本功的掌握：

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

　　(2)对数组越界把握的敏感度；

　　(3)库函数strcpy的工做方式，若是编写一个标准strcpy函数的总分值为10，下面给出几个不一样得分的答案：

　　2分

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

void strcpy( char *strDest, const char *strSrc )
//将源字符串加const，代表其为输入参数，加2分
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}
　　7分

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

//为了实现链式操做，将目的地址返回，加3分！

char * strcpy( char *strDest, const char *strSrc )
{
　assert( (strDest != NULL) && (strSrc != NULL) );
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0’ );
　　return address;
}
　　从2分到10分的几个答案咱们能够清楚的看到，小小的strcpy居然暗藏着这么多玄机，真不是盖的！须要多么扎实的基本功才能写一个完美的strcpy啊！

　　(4)对strlen的掌握，它没有包括字符串末尾的'\0'。

　　读者看了不一样分值的strcpy版本，应该也能够写出一个10分的strlen函数了，完美的版本为： int strlen( const char *str ) //输入参数const

{
　assert( strt != NULL ); //断言字符串地址非0
　int len;
　while( (*str++) != '\0' )
　{
　　len++;
　}
　return len;
}
　　试题4：

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

void Test( void )
{
　char *str = NULL;
　GetMemory( str );
　strcpy( str, "hello world" );
　printf( str );
}
　　试题5：

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

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

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

void Test( void )
{
　char *str = NULL;
　GetMemory( &str, 100 );
　strcpy( str, "hello" );
　printf( str );
}
　　试题7：

void Test( void )
{
　char *str = (char *) malloc( 100 );
　strcpy( str, "hello" );
　free( str );
　... //省略的其它语句
}
　　解答：

　　试题4传入中GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完

char *str = NULL;
GetMemory( str );
　　后的str仍然为NULL；

　　试题5中

char p[] = "hello world";
return p;
　　的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。

　　试题6的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，可是在GetMemory中执行申请内存及赋值语句

*p = (char *) malloc( num );
　　后未判断内存是否申请成功，应加上：

if ( *p == NULL )
{
　...//进行申请内存失败处理
}
　　试题7存在与试题6一样的问题，在执行

char *str = (char *) malloc(100);
　　后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，致使可能变成一个“野”指针，应加上：

str = NULL;
　　试题6的Test函数中也未对malloc的内存进行释放。

　　剖析：

　　试题4～7考查面试者对内存操做的理解程度，基本功扎实的面试者通常都能正确的回答其中50~60的错误。可是要彻底解答正确，却也绝非易事。

　　对内存操做的考查主要集中在：

　　（1）指针的理解；

　　（2）变量的生存期及做用范围；

　　（3）良好的动态内存申请和释放习惯。

　　再看看下面的一段程序有什么错误：

swap( int* p1,int* p2 )
{
　int *p;
　*p = *p1;
　*p1 = *p2;
　*p2 = *p;
}
　　在swap函数中，p是一个“野”指针，有可能指向系统区，致使程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改成：

swap( int* p1,int* p2 )
{
　int p;
　p = *p1;
　*p1 = *p2;
　*p2 = p;
}[img=12,12]file:///D:/鱼鱼软件/鱼鱼多媒体日记本/temp/{56068A28-3D3B-4D8B-9F82-AC1C3E9B128C}_arc_d[1].gif[/img] 3.内功题

　　试题1：分别给出BOOL，int，float，指针变量与“零值”比较的 if 语句（假设变量名为var）

　　解答：

　　　BOOL型变量：if(!var)

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

　　　float型变量：

　　　const float EPSINON = 0.00001;

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

　　　指针变量：　　if(var==NULL)

　　剖析：

　　考查对0值判断的“内功”，BOOL型变量的0判断彻底能够写成if(var==0)，而int型变量也能够写成if(!var)，指针变量的判断也能够写成if(!var)，上述写法虽然程序都能正确运行，可是未能清晰地表达程序的意思。
　通常的，若是想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，代表其为“逻辑”判断；若是用if判断一个数值型变量(short、int、long等)，应该用if(var==0)，代表是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这是一种很好的编程习惯。

　　浮点型变量并不精确，因此不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。若是写成if (x == 0.0)，则判为错，得0分。

　　试题2：如下为Windows NT下的32位C++程序，请计算sizeof的值

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

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

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

　　Func ( char str[100] )函数中数组名做为函数形参时，在函数体内，数组名失去了自己的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，能够做自增、自减等操做，能够被修改。

　　数组名的本质以下：

　　（1）数组名指代一种数据结构，这种数据结构就是数组；

　　例如：

char str[10];
cout ＜＜ sizeof(str) ＜＜ endl;
　　输出结果为10，str指代数据结构char[10]。

　　（2）数组名能够转换为指向其指代实体的指针，并且是一个指针常量，不能做自增、自减等操做，不能被修改；

char str[10];
str++; //编译出错，提示str不是左值　
　　（3）数组名做为函数形参时，沦为普通指针。

　　Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。

　　试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？

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

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

　　剖析：

　　这个面试题主要考查面试者对宏定义的使用，宏定义能够实现相似于函数的功能，可是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。

　　程序员对宏定义的使用要很是当心，特别要注意两个问题：

　　（1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。因此，严格地讲，下述解答：

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

　　（2）防止宏的反作用。

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

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

　　这个表达式会产生反作用，指针p会做三次++自增操做。

　　除此以外，另外一个应该判0分的解答是：

#define MIN(A,B) ((A) <= (B) ? (A) : (B));
　　这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。

　　试题4：为何标准头文件都有相似如下的结构？

#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus

extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}

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

　　头文件中的编译宏

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

　　做为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不一样。例如，假设某个函数的原型为：

void foo(int x, int y);
　　该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。

　　为了实现C和C++的混合编程，C++提供了C链接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就能够调用C++的函数了。 [img=12,12]file:///D:/鱼鱼软件/鱼鱼多媒体日记本/temp/{C74A38C4-432E-4799-B54D-73E2CD3C5206}_arc_d[1].gif[/img]
试题5：编写一个函数，做用是把一个char组成的字符串循环右移n个。好比原来是“abcdefghi”若是n=2，移位后应该是“hiabcdefgh”

　　函数头是这样的：

//pStr是指向以'\0'结尾的字符串的指针
//steps是要求移动的n

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

　　正确解答1：

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

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

　　这个试题主要考查面试者对标准库函数的熟练程度，在须要的时候引用库函数能够很大程度上简化程序编写的工做量。

　　最频繁被使用的库函数包括：

　　（1） strcpy

　　（2） memcpy

　　（3） memset

nGET和POST是两种最经常使用的与服务器进行交互的HTTP方法

nGET

nGET的语义是获取指定URL的资源

n将数据按照variable=value的形式，添加到action所指向的URL后面，而且二者使用"?"链接，各变量之间使用"&"链接

n貌似不安全，由于在传输过程当中，数据被放在请求的URL中

n传输的数据量小，这主要是由于受URL长度限制

nPOST

nPOST的语义是向指定URL的资源添加数据

n将数据放在数据体中，按照变量和值相对应的方式，传递到action所指向URL

n全部数据对用户来讲不可见

n能够传输大量数据，上传文件只能使用Pos

大多数求职者只会答出get时安全的，post时不安全的，但这个答案是错误的！！

真正的区别在于：

get请求时一个取的过程，没有数据体的存在，

对于用户而言，get是不安全的，发送的参数都裸露在外边

对于服务器而言，它时安全的，由于它没有给服务器发送真正的数据体

post请求时一个先发再取的过程，右数据体的存在

对于用户而言，post时相对安全的，由于发送的参数都在数据体中隐藏着

对于服务器而言，它是不安全的，由于它能够给服务器发送真正的数据体，若是有人想攻击这台服务器，彻底能够控制大量的计算机给这台服务器发送post请求，就会形成拒绝服务攻击

1. Object－c的类能够多重继承么？能够实现多个接口么？Category是什么？重写一个类的方式用继承好仍是分类好？为何？

Object-c的类不能够多重继承；能够实现多个接口，经过实现多个接口能够完成C++的多重继承；Category是类别，通常状况用分类好，用Category去重写类的方法，仅对本Category有效，不会影响到其余类与原有类的关系。

2.#import 跟#include 又什么区别，@class呢, ＃import<> 跟 #import”"又什么区别？

#import是Objective-C导入头文件的关键字，#include是C/C++导入头文件的关键字,使用#import头文件会自动只导入一次，不会重复导入，至关于#include和#pragma once；@class告诉编译器某个类的声明，当执行时，才去查看类的实现文件，能够解决头文件的相互包含；#import<>用来包含系统的头文件，#import””用来包含用户头文件。

3. 属性readwrite，readonly，assign，retain，copy，nonatomic 各是什么做用，在那种状况下用？

readwrite 是可读可写特性；须要生成getter方法和setter方法时

readonly 是只读特性只会生成getter方法不会生成setter方法 ;不但愿属性在类外改变

assign 是赋值特性，setter方法将传入参数赋值给实例变量；仅设置变量时；

retain 表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;

copy 表示拷贝特性，setter方法将传入对象复制一份；须要彻底一份新的变量时。

nonatomic 非原子操做，决定编译器生成的setter getter是不是原子操做，atomic表示多线程安全，通常使用nonatomic

4.写一个setter方法用于完成@property （nonatomic,retain）NSString *name,写一个setter方法用于完成@property（nonatomic，copy）NSString *name

[cpp] view plain copy print ?

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

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

5.对于语句NSString*obj = [[NSData alloc] init]; obj在编译时和运行时分别时什么类型的对象？

编译时是NSString的类型；运行时是NSData类型的对象

6.常见的object-c的数据类型有那些，和C的基本数据类型有什么区别？如：NSInteger和int

object-c的数据类型有NSString，NSNumber，NSArray，NSMutableArray，NSData等等，这些都是class，建立后即是对象，而C语言的基本数据类型int，只是必定字节的内存空间，用于存放数值；NSInteger是基本数据类型，并非NSNumber的子类，固然也不是NSObject的子类。NSInteger是基本数据类型Int或者Long的别名（NSInteger的定义typedef long NSInteger），它的区别在于，NSInteger会根据系统是32位仍是64位来决定是自己是int仍是Long。

7.id 声明的对象有什么特性？

Id 声明的对象具备运行时的特性，便可以指向任意类型的objcetive-c的对象；

8.Objective-C如何对内存管理的,说说你的见解和解决方法?

Objective-C的内存管理主要有三种方式ARC（自动内存计数）、手动内存计数、内存池。

9.内存管理的几条原则时什么？按照默认法则.那些关键字生成的对象

须要手动释放？在和property结合的时候怎样有效的避免内存泄露？

谁申请，谁释放

遵循Cocoa Touch的使用原则；

内存管理主要要避免“过早释放”和“内存泄漏”，对于“过早释放”须要注意@property设置特性时，必定要用对特性关键字，对于“内存泄漏”，必定要申请了要负责释放，要细心。

关键字alloc 或new 生成的对象须要手动释放；

设置正确的property属性，对于retain须要在合适的地方释放，

10.如何对iOS设备进行性能测试?

Profile-> Instruments ->Time Profiler

11.看下面的程序,第一个NSLog会输出什么？这时str的retainCount是多少？第二个和第三个呢？为何？

[cpp] view plain copy print ?

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

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

str的retainCount建立+1，retain+1，加入数组自动+1

retain+1，release-1，release-1

数组删除全部对象，全部数组内的对象自动-1

12. Object C中建立线程的方法是什么？若是在主线程中执行代码，方法是什么？若是想延时执行代码、方法又是什么？

线程建立有三种方法：使用NSThread建立、使用GCD的dispatch、使用子类化的NSOperation,而后将其加入NSOperationQueue;在主线程执行代码，方法是performSelectorOnMainThread，若是想延时执行代码能够用performSelector:onThread:withObject: afterDelay: 或者使用GCD的函数：dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后异步执行这里的代码...
});

13.描述一下iOS SDK中如何实现MVC的开发模式

MVC是模型、试图、控制开发模式，对于iOS SDK，全部的View都是视图层的，它应该独立于模型层，由视图控制层来控制。全部的用户数据都是模型层，它应该独立于视图。全部的ViewController都是控制层，由它负责控制视图，访问模型数据

浅复制和深复制的区别？
答案：浅层复制：只复制指向对象的指针，而不复制引用对象自己。
深层复制：复制引用对象自己。
意思就是说我有个A对象，复制一份后获得A_copy对象后，对于浅复制来讲，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象自己资源
仍是只有一份，那若是咱们对A_copy执行了修改操做,那么发现A引用的对象一样被修改，这其实违背了咱们复制拷贝的一个思想。深复制就好理解了,内存中存在了
两份独立对象自己。
用网上一哥们通俗的话将就是：
浅复制比如你和你的影子，你完蛋，你的影子也完蛋
深复制比如你和你的克隆人，你完蛋，你的克隆人还活着。

2.What is advantage of categories? What is difference between implementing a category and inheritance?
类别的做用？继承和类别在实现中有何区别？
答案：category 能够在不获悉，不改变原来代码的状况下往里面添加新的方法，只能添加，不能删除修改。
而且若是类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，由于类别具备更高的优先级。
类别主要有3个做用：
(1)将类的实现分散到多个不一样文件或多个不一样框架中。
(2)建立对私有方法的前向引用。
(3)向对象添加非正式协议。
继承能够增长，扩展父类方法，而且能够增长属性。

3.Difference between categories and extensions?
类别和类扩展的区别。
答案：category和extensions的不一样在于后者能够添加属性。另外后者添加的方法是必需要实现的。
extensions能够认为是一个私有的Category。

4.Difference between protocol in objective c and interfaces in java?
oc中的协议和java中的接口概念有何不一样？
答案：OC中的协议有2层含义，官方定义为 formal和informal protocol。前者和Java接口同样。
informal protocol中的方法属于设计模式考虑范畴，不是必须实现的，可是若是有实现，就会改变类的属性。
其实关于正式协议，类别和非正式协议我很早前学习的时候大体看过，也写在了学习教程里
“非正式协议概念其实就是类别的另外一种表达方式“这里有一些你可能但愿实现的方法，你能够使用他们更好的完成工做”。
这个意思是，这些是可选的。好比我门要一个更好的方法，咱们就会申明一个这样的类别去实现。而后你在后期能够直接使用这些更好的方法。
这么看，总以为类别这玩意儿有点像协议的可选协议。"
如今来看，其实protocal已经开始对二者都统一和规范起来操做，由于资料中说“非正式协议使用interface修饰“，
如今咱们看到协议中两个修饰词：“必须实现(@requied)”和“可选实现(@optional)”。

5.What are KVO and KVC?
答案：kvc:键 - 值编码是一种间接访问对象的属性使用字符串来标识属性，而不是经过调用存取方法，直接或经过实例变量访问的机制。
不少状况下能够简化程序代码。apple文档其实给了一个很好的例子。
kvo:键值观察机制，他提供了观察某一属性变化的方法，极大的简化了代码。
具体用看到嗯哼用到过的一个地方是对于按钮点击变化状态的的监控。
好比我自定义的一个button
[cpp]
[self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];

#pragma mark KVO

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

对于系统是根据keypath去取的到相应的值发生改变，理论上来讲是和kvc机制的道理是同样的。
对于kvc机制如何经过key寻找到value：
“当经过KVC调用对象时，好比：[self valueForKey:@”someKey”]时，程序会自动试图经过几种不一样的方式解析这个调用。首先查找对象是否带有 someKey 这个方法，若是没找到，会继续查找对象是否带有someKey这个实例变量（iVar），若是尚未找到，程序会继续试图调用 -(id) valueForUndefinedKey:这个方法。若是这个方法仍是没有被实现的话，程序会抛出一个NSUndefinedKeyException异常错误。

(cocoachina.com注：Key-Value Coding查找方法的时候，不只仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及_getsomeKey这几种形式。同时，查找实例变量的时候也会不只仅查找someKey这个变量，也会查找_someKey这个变量是否存在。）

设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象可以在错误发生前，有最后的机会响应这个请求。这样作有不少好处，下面的两个例子说明了这样作的好处。“
来至cocoa，这个说法应该挺有道理。
由于咱们知道button倒是存在一个highlighted实例变量.所以为什么上面咱们只是add一个相关的keypath就好了，
能够按照kvc查找的逻辑理解，就说的过去了。

6.What is purpose of delegates?
代理的做用？
答案：代理的目的是改变或传递控制链。容许一个类在某些特定时刻通知到其余类，而不须要获取到那些类的指针。能够减小框架复杂度。
另一点，代理能够理解为java中的回调监听机制的一种相似。

7.What are mutable and immutable types in Objective C?
oc中可修改和不能够修改类型。
答案：可修改不可修改的集合类。这个我我的简单理解就是可动态添加修改和不可动态添加修改同样。
好比NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者能够添加等，能够动态申请新的内存空间。

8.When we call objective c is runtime language what does it mean?
咱们说的oc是动态运行时语言是什么意思？
答案：多态。主要是将数据类型的肯定由编译时，推迟到了运行时。
这个问题其实浅涉及到两个概念，运行时和多态。
简单来讲，运行时机制使咱们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。
多态：不一样对象以本身的方式响应相同的消息的能力叫作多态。意思就是假设生物类（life）都用有一个相同的方法-eat;
那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，可是调用是咱们只需调用各自的eat方法。
也就是不一样的对象以本身的方式响应了相同的消息（响应了eat这个选择器）。
所以也能够说，运行时机制是多态的基础？~~~

9.what is difference between NSNotification and protocol?
通知和协议的不一样之处？
答案：协议有控制链(has-a)的关系，通知没有。
首先我一开始也不太明白，什么叫控制链（专业术语了~）。可是简单分析下通知和代理的行为模式，咱们大体能够有本身的理解
简单来讲，通知的话，它能够一对多，一条消息能够发送给多个消息接受者。
代理按咱们的理解，到不是直接说不能一对多，好比咱们知道的明星经济代理人，不少时候一个经济人负责好几个明星的事务。
只是对于不一样明星间，代理的事物对象都是不同的，一一对应，不可能说明天要处理A明星要一个发布会，代理人发出处理发布会的消息后，别称B的
发布会了。可是通知就不同，他只关心发出通知，而不关心多少接收到感兴趣要处理。
所以控制链（has-a从英语单词大体能够看出，单一拥有和可控制的对应关系。

10.What is push notification?
什么是推送消息？
答案：太简单，不做答~~~~~~~~~~
这是cocoa上的答案。
其实到不是说太简单，只是太泛泛的一个概念的东西。就比如说，什么是人。
推送通知更是一种技术。
简单点就是客户端获取资源的一种手段。
普通状况下，都是客户端主动的pull。
推送则是服务器端主动push。测试push的实现能够查看该博文。

11.Polymorphism？
关于多态性
答案：多态，父类指针指向子类对象。
这个题目其实能够出到一切面向对象语言中，
所以关于多态，继承和封装基本最好都有个自我意识的理解，也并不是必定要把书上资料上写的能背出来。
最重要的是转化成自我理解。

12.Singleton?
对于单例的理解
答案：11，12题目其实出的有点泛泛的感受了，可能说是编程语言须要或是必备的基础。
基本能用熟悉的语言写出一个单例，以及能够运用到的场景或是你编程中碰到过运用的此种模式的框架类等。
进一步点，考虑下如何在多线程访问单例时的安全性。

13.What is responder chain?
说说响应链
答案：事件响应链。包括点击事件，画面刷新事件等。在视图栈内从上至下，或者从下之上传播。
能够说点事件的分发，传递以及处理。具体能够去看下touch事件这块。由于问的太抽象化了
严重怀疑题目出到越后面就越笼统。

能够从责任链模式，来说经过事件响应链处理，其拥有的扩展性

14.Difference between frame and bounds?
frame和bounds有什么不一样？
答案:frame指的是：该view在父view坐标系统中的位置和大小。（参照点是父亲的坐标系统）
bounds指的是：该view在自己坐标系统中的位置和大小。（参照点是自己坐标系统）

15.Difference between method and selector?
方法和选择器有何不一样？
答案：selector是一个方法的名字，method是一个组合体，包含了名字和实现.
详情能够看apple文档。

16.Is there any garbage collection mechanism in Objective C.?
OC的垃圾回收机制？
答案： OC2.0有Garbage collection，可是iOS平台不提供。
通常咱们了解的objective-c对于内存管理都是手动操做的，可是也有自动释放池。
可是差了大部分资料，貌似不要和arc机制搞混就行了。
求更多~~

17.NSOperation queue?
答案：存放NSOperation的集合类。
操做和操做队列，基本能够当作java中的线程和线程池的概念。用于处理ios多线程开发的问题。
网上部分资料提到一点是，虽然是queue，可是却并非带有队列的概念，放入的操做并不是是按照严格的先进现出。
这边又有个疑点是，对于队列来讲，先进先出的概念是Afunc添加进队列，Bfunc紧跟着也进入队列，Afunc先执行这个是必然的，
可是Bfunc是等Afunc彻底操做完之后，B才开始启动而且执行，所以队列的概念理论上有点违背了多线程处理这个概念。
可是转念一想其实能够参考银行的取票和叫号系统。
所以对于A比B先排队取票可是B率先执行完操做，咱们亦然能够感性认为这仍是一个队列。
可是后来看到一票关于这操做队列话题的文章，其中有一句提到
“由于两个操做提交的时间间隔很近，线程池中的线程，谁先启动是不定的。”
瞬间以为这个queue名字有点忽悠人了，还不如pool~
综合一点，咱们知道他能够比较大的用处在于能够帮助多线程编程就行了。

楼上区分了线程执行时的次序（Afunc和Bfunc谁先启动）和线程执行完成（Afunc和Bfunc谁先执行完）时的次序不一样，而多线程的重要概念是并发（同时执行多个任务），NSOperationQueue是管理并发线程的对象，能够在其中放入NSOpertation对象（对象化的线程实体），经过设置maxConcurrentOperationCount的大小，控制并发数目，如楼上所说但愿“Afunc添加进队列，执行完后，Bfunc紧跟进入队列，继续执行”，那只需将maxConcurrentOperationCount设为1，变会依次执行，这时候实际是在单线程依次执行。因此这里的NSOperationQueue就是对象化抽象的去管理多线程，这样的好处，使用者经过继承NSOperation对象，能够方便的用对象来管理线程，而再也不用关心线程同步、信号量等细节，更多地关注于业务逻辑。

18.What is lazy loading?
答案：懒汉模式，只在用到的时候才去初始化。
也能够理解成延时加载。
我以为最好也最简单的一个列子就是tableView中图片的加载显示了。
一个延时载，避免内存太高，一个异步加载，避免线程堵塞。

19.Can we use two tableview controllers on one viewcontroller?
是否在一个视图控制器中嵌入两个tableview控制器？
答案：一个视图控制只提供了一个View视图，理论上一个tableViewController也不能放吧，
只能说能够嵌入一个tableview视图。固然，题目自己也有歧义，若是不是咱们定性思惟认为的UIViewController，
而是宏观的表示视图控制者，那咱们却是能够把其当作一个视图控制者，它能够控制多个视图控制器，好比TabbarController
那样的感受。

20.Can we use one tableview with two different datasources? How you will achieve this?
一个tableView是否能够关联两个不一样的数据源？你会怎么处理？
答案：首先咱们从代码来看，数据源如何关联上的，实际上是在数据源关联的代理方法里实现的。
所以咱们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据本身的须要去设置如相关的数据源。
所以，我以为能够设置多个数据源啊，可是有个问题是，你这是想干吗呢？想让列表如何显示，不一样的数据源分区块显示？

1. 你使用过Objective-C的运行时编程（Runtime Programming）么？若是使用过，你用它作了什么？你还能记得你所使用的相关的头文件或者某些方法的名称吗？

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

同运行时交互主要在三个不一样的地方，分别是

A.Objective-C 源码（譬如：你定义的Category中的新方法会在运行时自动添加到原始类）

B.NSObject 的方法（isMemberClassOf 等动态判定的方法）

C.运行时函数。

Objective-C跟C最大的差异，应当是动态定型（dynamicaly typed），支撑在运行时

动态类型决定（dynamic typing），动态绑定（dynamic binding）以及动态装载（dynamic loading）。

Objective-C 在运行时能够允许按照字符串名字来接见办法和类，还能够动态链接和添加类，

而C说话编译时静态绑定，甚至不少时辰你没定义的办法直接就编译不过。

用过objc_getClass()和class_copyMethodList()获取过私有API;使用
```objective-c
Method method1 = class_getInstanceMethod(cls, sel1);
Method method2 = class_getInstanceMethod(cls, sel2);
method_exchangeImplementations(method1, method2);
```

代码交换两个方法，在写unit test时使用到。

2.你实现过多线程的Core Data么？NSPersistentStoreCoordinator，NSManagedObjectContext和NSManagedObject中的哪些须要在线程中建立或者传递？你是用什么样的策略来实现的？
没实现过多线程的CoreData(待实践)

Core Data是iOS5以后才出现的一个框架，它提供了对象-关系映射(ORM)的功能，即可以将OC对象转化成数据，保存在SQLite数据库文件中，也可以将保存在数据库中的数据还原成OC对象。在此数据操做期间，咱们不须要编写任何SQL语句，这个有点相似于著名的Hibernate持久化框架，不过功能确定是没有Hibernate强大的。简单地用下图描述下它的做用：

利用Core Data框架，咱们就能够轻松地将数据库里面的2条记录转换成2个OC对象，也能够轻松地将2个OC对象保存到数据库中，变成2条表记录，并且不用写一条SQL语句, 另外支持自动撤销机制，一对多关联等

Core data 是 Cocoa 中处理数据，绑定数据的关键特性，其重要性不言而喻，但也比较复杂。Core Data 相关的类比较多，初学者每每不太容易弄懂。计划用三个教程来说解这一部分：

3.Core开头的系列的内容。是否使用过CoreAnimation和CoreGraphics。UI框架和CA，CG框架的联系是什么？分别用CA和CG作过些什么动画或者图像上的内容。（有须要的话还能够涉及Quartz的一些内容）
UI框架的底层有CoreAnimation，CoreAnimation的底层有CoreGraphics。
UIKit |
------------ |
Core Animation |
Core Graphics |
Graphics Hardware|
使用CA作过menu菜单的展开收起（太逊了）

是否使用过CoreText或者CoreImage等？若是使用过，请谈谈你使用CoreText或者CoreImage的体验。
CoreText能够解决复杂文字内容排版问题。CoreImage能够处理图片，为其添加各类效果。体验是很强大，挺复杂的。

4. NSNotification和KVO的区别和用法是什么？何时应该使用通知，何时应该使用KVO，它们的实现上有什么区别吗？若是用protocol和delegate（或者delegate的Array）来实现相似的功能可能吗？若是可能，会有什么潜在的问题？若是不能，为何？（虽然protocol和delegate这种东西面试已经面烂了…）

NSNotification是通知模式在iOS的实现，

KVC（key-value coding）是一个经过属性名访问属性变量的机制。

KVO的全称是键值观察(Key-value observing),其是基于KVC的，

例如将Module层的变化，通知到多个Controller对象时，能够使用NSNotification；若是是只须要观察某个对象的某个属性，能够使用KVO。
对于委托模式，在设计模式中是对象适配器模式，其是delegate是指向某个对象的，这是一对一的关系，

而在通知模式中，每每是一对多的关系。

委托模式，从技术上能够实现改变delegate指向的对象，但不建议这样作，会让人迷惑，若是一个delegate对象不断改变，指向不一样的对象。

6.你用过NSOperationQueue么？若是用过或者了解的话，你为何要使用NSOperationQueue，实现了什么？请描述它和GCD的区别和相似的地方（提示：能够从二者的实现机制和适用范围来描述）。
使用NSOperationQueue用来管理子类化的NSOperation对象，控制其线程并发数目。

GCD和NSOperation都能够实现对线程的管理，区别是 NSOperation和NSOperationQueue是多线程的面向对象抽象。

项目中使用NSOperation的优势是NSOperation是对线程的高度抽象，在项目中使用它，会使项目的程序结构更好，子类化NSOperation的设计思路，是具备面向对象的优势（复用、封装），使得实现是多线程支持，而接口简单，建议在复杂项目中使用。
项目中使用GCD的优势是GCD自己很是简单、易用，对于不复杂的多线程操做，会节省代码量，而Block参数的使用，会是代码更为易读，建议在简单项目中使用。

7.既然提到GCD，那么问一下在使用GCD以及block时要注意些什么？它们两是一回事儿么？block在ARC中和传统的MRC中的行为和用法有没有什么区别，须要注意些什么？
使用block是要注意，

若将block作函数参数时，须要把它放到最后，

GCD是Grand Central Dispatch，

是一个对线程开源类库，而Block是闭包，是可以读取其余函数内部变量的函数。

block自身的内存管理**

block自己是像对象同样能够retain，和release。可是，block在建立的时候，它的内存是分配在栈(stack)上，而不是在堆(heap)上。他自己的做于域是属于建立时候的做用域，一旦在建立时候的做用域外面调用block将致使程序崩溃，

在其余地方使用的解决方法是，建完block的时候须要调用copy的方法。copy会把block从栈上移动到堆上，那么就能够在其余地方使用这个block了~

block中能够直接使用外部的变量

block循环引用

当在block内部使用成员变量的时候调用 self.str (str是self成员变量)， block内部调用 self.str 时，str会retain一次，此时当self释放的时候，须要block释放后才会对self进行释放，可是block的释放又须要等self的dealloc中才会释放。如此一来变造成了循环引用，致使内存泄露。

修改方案：是新建一个__block scopeVC的局部变量，并把self赋值给它，而在block内部则使用这个局部变量来进行取值。由于__block标记的变量是不会被自动retain的

8.您是否作过异步的网络处理和通信方面的工做？若是有，能具体介绍一些实现策略么？
使用NSOperation发送异步网络请求，使用NSOperationQueue管理线程数目及优先级，底层是用NSURLConnetion，详细可见开源框架[LWConnetion](https://github.com/xunyn/LWConnetionDemo)。

9. 对于Objective-C，你认为它最大的优势和最大的不足是什么？对于不足之处，如今有没有可用的方法绕过这些不足来实现需求。若是能够的话，你有没有考虑或者实践太重新实现OC的一些功能，若是有，具体会如何作？
最大的优势是它的运行时特性，不足是没有命名空间，对于命名冲突，能够使用长命名法或特殊前缀解决，若是是引入的第三方库之间的命名冲突，能够使用link命令及flag解决冲突。

10. 你实现过一个框架或者库以供别人使用么？若是有，请谈一谈构建框架或者库时候的经验；若是没有，请设想和设计框架的public的API，并指出大概须要如何作、须要注意一些什么方面，来使别人容易地使用你的框架。
抽象和封装，方便使用。首先是对问题有充分的了解，好比构建一个文件解压压缩框架，从使用者的角度出发，只需关注发送给框架一个解压请求，框架完成复杂文件的解压操做，而且在适当的时候通知给是哦难过者，如解压完成、解压出错等。在框架内部去构建对象的关系，经过抽象让其更为健壮、便于更改。其次是API的说明文档。