作者: DVWang | 来源:发表于2017-09-08 11:58 被阅读28次

    链表和数组的区别在哪里?

    二者都属于一种数据结构
    从逻辑结构来看

    1. 数组必须事先定义固定的长度(元素个数),不能适应数据动态地增减的情况。当数据增加时,可能超出原先定义的元素个数;当数据减少时,造成内存浪费;数组可以根据下标直接存取。
    2. 链表动态地进行存储分配,可以适应数据动态地增减的情况,且可以方便地插入、删除数据项。(数组中插入、删除数据项时,需要移动其它数据项,非常繁琐)链表必须根据next指针找到下一个元素
      从内存存储来看
    3. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小
    4. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦

    从上面的比较可以看出,如果需要快速访问数据,很少或不插入和删除元素,就应该用数组;相反, 如果需要经常插入和删除元素就需要用链表数据结构了。

    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].

    写一个委托的interface

    @protocol MyDelegate;
    @interface MyClass: NSObject
    { id <MyDelegate> delegate; }
    //委托方法@protocol MyDelegate- (void)didJobs:(NSArray *)args;
    @end

    写一个NSString类的实现

    +(id)initWithCString:(const char *)nullTerminatedCStringencoding:(NSStringEncoding)encoding;

    • (id)stringWithCString: (const char*)nullTerminatedCString encoding: (NSStringEncoding)encoding
      { NSString *obj;
      obj = [selfallocWithZone: NSDefaultMallocZone()];
      obj = [objinitWithCString: nullTerminatedCString encoding: encoding];
      returnAUTORELEASE(obj);
      }

    关键字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 类型。

    为什么标准头文件都有类似以下的结构?

    ifndef __INCvxWorksh

    define __INCvxWorksh

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

    endif

    endif /* __INCvxWorksh */

    显然,头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。

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

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

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

    答案:原子操作、信号量机制、自旋锁、管程、会合、分布式系统
    进程之间通信的途径
    答案:共享存储系统消息传递系统管道:以文件系统为基础
    进程死锁的原因
    答案:资源竞争及进程推进顺序非法
    死锁的4个必要条件
    答案:互斥、请求保持、不可剥夺、环路
    死锁的处理
    答案:鸵鸟策略、预防策略、避免策略、检测与解除死锁

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

    答:模型的性质是通过一个简单的键(通常是个字符串)来指定的。视图和控制器通过键来查找相应的属性值。在一个给定的实体中,同一个属性的所有值具有相同的数据类型。键-值编码技术用于进行这样的查找—它是一种间接访问对象属性的机制。
    键路径是一个由用点作分隔符的键组成的字符串,用于指定一个连接在一起的对象性质序列。第一个键的性质是由先前的性质决定的,接下来每个键的值也是相对于其前面的性质。键路径使您可以以独立于模型实现的方式指定相关对象的性质。通过键路径,您可以指定对象图中的一个任意深度的路径,使其指向相关对象的特定属性。
    For example, the keypath address.streetwould get the value of the address property from thereceivingobject, and then determine the street property relative to the addressobject.

    c和obj-c如何混用

    1)obj-c的编译器处理后缀为m的文件时,可以识别obj-c和c的代码,处理mm文件可以识别obj-c,c,c++代码,但cpp文件必须只能用c/c++代码,而且cpp文件include的头文件中,也不能出现obj-c的代码,因为cpp只是cpp

    1. 在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.

    目标-动作机制

    答:目标是动作消息的接收者。一个控件,或者更为常见的是它的单元,以插座变量(参见"插座变量"部分) 的形式保有其动作消息的目标。
    动作是控件发送给目标的消息,或者从目标的角度看,它是目标为了响应动作而实现的方法。程序需要某些机制来进行事件和指令的翻译。这个机制就是目标-动作机制。

    cocoa touch框架

    这些框架包括:
    Core Animation
    通过Core Animation,您就可以通过一个基于组合独立图层的简单的编程模型来创建丰富的用户体验。
    Core Audio
    Core Audio是播放,处理和录制音频的专业技术,能够轻松为您的应用程序添加强大的音频功能。
    Core Data提供了一个面向对象的数据管理解决方案,它易于使用和理解,甚至可处理任何应用或大或小的数据模型。
    功能列表:框架分类
    下面是 Cocoa Touch 中一小部分可用的框架:
    音频和视频
    CoreAudio
    OpenAL
    MediaLibrary
    AVFoundation
    数据管理
    Core Data
    SQLite
    图形和动画
    CoreAnimation
    OpenGL ES
    Quartz 2D
    网络/li>
    Bonjour
    WebKit
    BSDSockets
    用户应用
    AddressBook
    CoreLocation
    MapKit
    StoreKit

    objc的内存管理

    答:如果您通过分配和初始化(比如[[MyClass alloc] init])的方式来创建对象,您就拥有这个对象,需要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也同样适用。
    如果您拷贝一个对象,您也拥有拷贝得到的对象,需要负责该对象的释放。如果您保持一个对象,您就部分拥有这个对象,需要在不再使用时释放该对象。反过来,如果您从其它对象那里接收到一个对象,则您不拥有该对象,也不应该释放它(这个规则有少数的例外,在参考文档中有显式的说明)。

    自动释放池是什么,如何工作?

    答:当您向一个对象发送一个autorelease消息时,Cocoa就会将该对象的一个引用放入到最新的自动释放池。它仍然是个正当的对象,因此自动释放池定义的作用域内的其它对象可以向它发送消息。当程序执行到作用域结束的位置时,自动释放池就会被释放,池中的所有对象也就被释放。
    1)ojc-c是通过一种"referring counting"(引用计数)的方式来管理内存的, 对象在开始分配内存(alloc)的时候引用计数为一,以后每当碰到有copy,retain的时候引用计数都会加一, 每当碰到release和autorelease的时候引用计数就会减一,如果此对象的计数变为了0, 就会被系统销毁.
    2) NSAutoreleasePool就是用来做引用计数的管理工作的,这个东西一般不用你管的.
    3)autorelease和release没什么区别,只是引用计数减一的时机不同而已,autorelease会在对象的使用真正结束的时候才做引用计数减一。

    类工厂方法是什么?

    答:类工厂方法的实现是为了向客户提供方便,它们将分配和初始化合在一个步骤中,返回被创建的对象,并进行自动释放处理。这些方法的形式是+ (type)className...(其中 className不包括任何前缀)。工厂方法可能不仅仅为了方便使用。它们不但可以将分配和初始化合在一起,还可以为初始化过程提供对象的分配信息。类工厂方法的另一个目的是使类(比如NSWorkspace)提供单件实例。虽然init...方法可以确认一 个类在每次程序运行过程只存在一个实例,但它需要首先分配一个“生的”实例,然后还必须释放该实例。工厂方法则可以避免为可能没有用的对象盲目分配内存。

    单件实例是什么?

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

    动态绑定

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

    obj-c的优缺点objc

    优点:

    1. Cateogies 2) Posing 3) 动态识别 4) 指标计算 5)弹性讯息传递 6) 不是一个过度复杂的 C 衍生语言 7) Objective-C 与 C++ 可混合编程
      缺点:
    2. 不支援命名空间 2) 不支持运算符重载 3) 不支持多重继承 4) 使用动态运行时类型,所有的方法都是函数调用,所以很多编译时优化方法都用不到。(如内联函数等),性能低劣。

    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格式化的函数的长度不可控,有可能格式化后的字符串会超出缓冲区的大小,造成溢出。

    协议:相当于一个方法列表,多个类可以共享的方法的列表

    代理:它是一个设计模式,本质就是两个对象之间的调用 id的范型

    MVC设计模式,一个架构级的思路,这个模式步局限某个平台

    model + View + Controller(模型+ 试图 +控制器)
    模型: 主要负责存储和操作的数据,理论上是和View没有联系的
    视图:负责展示数据和处理用户之间的交互
    控制器:主要前两者联系起来;
    达到模型和视图分离的效果,低偶和,单独修改或添加没有影响,复用非常方便,利于扩展和后期的维护,提高软件的开发效率,节约了开发成本。

    内存管理

    arc 和 mrc, xcode5.0后都是自动的
    arc原理和自动释放池原理,retain,copy,assgin,一个完整操作都会有一个自动释放池
    weak不能修饰基本数据类型,只能修饰对象(assgin 和 weak 类似,但上面有两个不同,weak修饰的对象销毁后,会自动置空 ,所以更安全)
    -fno-objc-arc / fobjc-arc
    问题:arc 中批量创建对象,无法做到及时对象(for循环)
    细节:xib 中的控件是weak修饰的,因为它们是添加到view上,防止强强引用
    内存查的工具,真机的情况下, instruments (专门的例子)

    试图控制器的生面周期(view 的生命周期)(内存优化的意识)

    内存告急的处理(手动释放不可见视图的内存和成员变量),将没有释放的,手动去释放
    这样之后会重新调用loadView viewDidLoad

    cell的重用机制,重用的对象

    (iOS6 之后的重用机制,可以提前注册cell)

    多线程的东西

    异步加载数据,相当于与应用多线程,UI主线程(分配的资源是最多的),分开了一段
    什么场景的时候应用 多线程------耗时操作(数据库中的读取,图片的处理(滤镜))

    图片操作;imageNamed: 加载小图片,缓存文件会自动清空,不占用程序的活跃内存。imageNamed的优点是当加载时会缓存图片。所以当图片会频繁的使用时,那么用imageNamed的方法会比较好

    iamgeWithContentsFile:大图片。每次调用,会占缓存
    imageWithContentsOfFile:仅加载图片,图像数据不会缓存。因此对于较大的图片以及使用情况较少时,那就可以用该方法,降低内存消耗。

    kvc kvo (点语法是kvc的一种,一种特殊的kvc)

    kvc : 内部批量调用 数组的名称 setValueForUnder
    kvo : 对符合kvc进行键值观察

    多线程 NSThread(系统的基本类) NSOperation、 GCD(结合着block 去应用)

    AFNetworking code 2.0
    效率: block delegate 通知中心
    block 是一个匿名函数,

    为了防止多个线程同时来使用 ,线程锁、syscn...

    FMDB 有一个线程安全,做了线程安全(FMDBQ)

    sqlite3 事物:try-catch,能提高效率 ,增加 可以看一下啊
    如果我们的app需要多线程操作数据库,那么就需要使用FMDatabaseQueue来保证线程安全了。切记不能在多个线程中共同一个FMDatabase对象并且在多个线程中同时使用,这个类本身不是线程安全的,这样使用会造成数据混乱等问题。
    使用FMDatabaseQueue很简单,首先用一个数据库文件地址来初使化FMDatabaseQueue,然后就可以将一个闭包(block)传入inDatabase方法中。在闭包中操作数据库,而不直接参与FMDatabase的管理。

    HTTP 协议,TCP,UDP

    http: 请求头、相应头、请求体、相应体

    oauth2.0

    IOS6,IOS7,iOS8 增加了三个库(智能家居的,手表的)

    iOS6 和 iOS7 1、 拟物化风格(现实生活) 和 扁平化风格(一切事物都变成线条的)2、原点的位置的不同, 3、 某些方法是不同的
    sprite kit (游戏引擎) / NSURLSeeion(可能代替 NSOperation)

    写一个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);
      }

    static 关键字的作用:

    (1)函数体内 static 变量的作用范围为该函数体,不同于 auto 变量,该变量的内存只被分配一次,
    因此其值在下次调用时仍维持上次的值;
    (2)在模块内的 static 全局变量可以被模块内所用函数访问,但不能被模块外其它函数访问;
    (3)在模块内的 static 函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明
    它的模块内;
    (4)在类中的 static 成员变量属于整个类所拥有,对类的所有对象只有一份拷贝;
    (5)在类中的 static 成员函数属于整个类所拥有,这个函数不接收 this 指针,因而只能访问类的static 成员变量。

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

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

    堆和栈的区别

    管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
    申请大小:
    栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在 WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。
    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
    碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出
    分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
    分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的。

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

    模型的性质是通过一个简单的键(通常是个字符串)来指定的。视图和控制器通过键来查找相应的属性值。在一个给定的实体中,同一个属性的所有值具有相同的数据类型。键-值编码技术用于进行这样的查找—它是一种间接访问对象属性的机制。
    键路径是一个由用点作分隔符的键组成的字符串,用于指定一个连接在一起的对象性质序列。第一个键的
    性质是由先前的性质决定的,接下来每个键的值也是相对于其前面的性质。键路径使您可以以独立于模型
    实现的方式指定相关对象的性质。通过键路径,您可以指定对象图中的一个任意深度的路径,使其指向相
    关对象的特定属性。

    目标-动作机制

    目标是动作消息的接收者。一个控件,或者更为常见的是它的单元,以插座变量(参见"插座变量"部分)
    的形式保有其动作消息的目标。
    动作是控件发送给目标的消息,或者从目标的角度看,它是目标为了响应动作而实现的方法。
    程序需要某些机制来进行事件和指令的翻译。这个机制就是目标-动作机制。

    objc的内存管理

    ?? 如果您通过分配和初始化(比如[[MyClass alloc] init])的方式来创建对象,您就拥
    有这个对象,需要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也同样适用。
    ?? 如果您拷贝一个对象,您也拥有拷贝得到的对象,需要负责该对象的释放。
    ?? 如果您保持一个对象,您就部分拥有这个对象,需要在不再使用时释放该对象。
    反过来,
    ?? 如果您从其它对象那里接收到一个对象,则您不拥有该对象,也不应该释放它(这个规则有少数
    的例外,在参考文档中有显式的说明)。

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

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

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

    类工厂方法是什么

    类工厂方法的实现是为了向客户提供方便,它们将分配和初始化合在一个步骤中,返回被创建的对象,并
    进行自动释放处理。这些方法的形式是+ (type)className...(其中 className不包括任何前缀)。
    工厂方法可能不仅仅为了方便使用。它们不但可以将分配和初始化合在一起,还可以为初始化过程提供对
    象的分配信息。
    类工厂方法的另一个目的是使类(比如NSWorkspace)提供单件实例。虽然init...方法可以确认一
    个类在每次程序运行过程只存在一个实例,但它需要首先分配一个“生的”实例,然后还必须释放该实例。
    工厂方法则可以避免为可能没有用的对象盲目分配内存。

    单件实例是什么

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

    动态绑定

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

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

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

    obj-c的优缺点

    objc优点:

    1. Cateogies
    2. Posing
    3. 动态识别
    4. 指标计算
      5)弹性讯息传递
    5. 不是一个过度复杂的 C 衍生语言
    6. Objective-C 与 C++ 可混合编程
      缺点:
    7. 不支援命名空间
    8. 不支持运算符重载
      3)不支持多重继承
      4)使用动态运行时类型,所有的方法都是函数调用,所以很多编译时优化方法都用不到。(如内联函数等),性能低劣。

    sprintf,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格式化的函数的长度不可控,有可能格式化后的字符串会超出缓冲区的大小,造成溢出。

    答案是:

    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

    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函数会变成下面这样:

    什么时候用delegate,什么时候用Notification?答:delegate针对one-to-one关系,并且reciever可以返回值 给sender,notification 可以针对one-to-one/many/none,reciever无法返回值给sender.所以,delegate用于sender希望接受到 reciever的某个功能反馈值,notification用于通知多个object某个事件。

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

    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 。

    "NSMutableString *"这个数据类型则是代表"NSMutableString"对象本身,这两者是有区别的。

    而NSString只是对象的指针而已。
    面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
    面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。;

    类别的作用

    类别主要有3个作用:
    (1)将类的实现分散到多个不同文件或多个不同框架中。
    (2)创建对私有方法的前向引用。
    (3)向对象添加非正式协议。
    类别的局限性
    有两方面局限性:
    (1)无法向类中添加新的实例变量,类别没有位置容纳实例变量。
    (2)名称冲突,即当类别中的方法与原始类方法名称冲突时,类别具有更高的优先级。类别方法将完全取代初始方法从而无法再使用初始方法。
    无法添加实例变量的局限可以使用字典对象解决

    关键字volatile有什么含意?并给出三个不同的例子:

    一个定义为volatile的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。精确地说就是,优化器在用到
    这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子:
    ? 并行设备的硬件寄存器(如:状态寄存器)
    ? 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
    ? 多线程应用中被几个任务共享的变量

    ? 一个参数既可以是const还可以是volatile吗?解释为什么。
    ? 一个指针可以是volatile 吗?解释为什么。

    下面是答案:
    ? 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
    ? 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
    22@synthesize 是系统自动生成getter和setter属性声明
    @dynamic 是开发者自已提供相应的属性声明
    @dynamic 意思是由开发人员提供相应的代码:对于只读属性需要提供 setter,对于读写属性需要提供 setter 和getter。@synthesize 意思是,除非开发人员已经做了,否则由编译器生成相应的代码,以满足属性声明。
    查阅了一些资料确定@dynamic的意思是告诉编译器,属性的获取与赋值方法由用户自己实现, 不自动生成。

    Difference between shallow copy and deep copy?

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

    What is advantage of categories? What is difference between implementing a category and inheritance?

    类别的作用?继承和类别在实现中有何区别?
    答案:category 可以在不获悉,不改变原来代码的情况下往里面添加新的方法,只能添加,不能删除修改。
    并且如果类别和原来类中的方法产生名称冲突,则类别将覆盖原来的方法,因为类别具有更高的优先级。
    类别主要有3个作用:
    (1)将类的实现分散到多个不同文件或多个不同框架中。
    (2)创建对私有方法的前向引用。
    (3)向对象添加非正式协议。
    继承可以增加,修改或者删除方法,并且可以增加属性。

    Difference between categories and extensions?

    类别和类扩展的区别。
    答案:category和extensions的不同在于 后者可以添加属性。另外后者添加的方法是必须要实现的。
    extensions可以认为是一个私有的Category。

    Difference between protocol in objective c and interfaces in java?

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

    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就行了,

    What is purpose of delegates?

    代理的作用?
    答案:代理的目的是改变或传递控制链。允许一个类在某些特定时刻通知到其他类,而不需要获取到那些类的指针。可以减少框架复杂度。
    另外一点,代理可以理解为java中的回调监听机制的一种类似。

    What are mutable and immutable types in Objective C?

    oc中可修改和不可以修改类型。
    答案:可修改不可修改的集合类。这个我个人简单理解就是可动态添加修改和不可动态添加修改一样。
    比如NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的,后者可以添加等,可以动态申请新的内存空间

    When we call objective c is runtime language what does it mean?

    我们说的oc是动态运行时语言是什么意思?
    答案:多态。主要是将数据类型的确定由编译时,推迟到了运行时。
    这个问题其实浅涉及到两个概念,运行时和多态。
    简单来说,运行时机制使我们直到运行时才去决定一个对象的类别,以及调用该类别对象指定方法。
    多态:不同对象以自己的方式响应相同的消息的能力叫做多态。意思就是假设生物类(life)都用有一个相同的方法-eat;
    那人类属于生物,猪也属于生物,都继承了life后,实现各自的eat,但是调用是我们只需调用各自的eat方法。
    也就是不同的对象以自己的方式响应了相同的消息(响应了eat这个选择器)。
    因此也可以说,运行时机制是多态的基础?~~~

    what is difference between NSNotification and protocol?

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

    What is push notification?

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

    Polymorphism?

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

    What is responder chain?

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

    Difference between frame and bounds?

    frame和bounds有什么不同?
    答案:frame指的是:该view在父view坐标系统中的位置和大小。(参照点是父亲的坐标系统)
    bounds指的是:该view在本身坐标系统中 的位置和大小。(参照点是本身坐标系统)

    Difference between method and selector?

    方法和选择器有何不同?
    答案:selector是一个方法的名字,method是一个组合体,包含了名字和实现.

    NSOperation queue?

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

    What is lazy loading?

    答案:懒汉模式,只在用到的时候才去初始化。
    也可以理解成延时加载。
    我觉得最好也最简单的一个列子就是tableView中图片的加载显示了。
    一个延时载,避免内存过高,一个异步加载,避免线程堵塞。

    Can we use two tableview controllers on one viewcontroller?

    是否在一个视图控制器中嵌入两个tableview控制器?
    答案:一个视图控制只提供了一个View视图,理论上一个tableViewController也不能放吧,
    只能说可以嵌入一个tableview视图。当然,题目本身也有歧义,如果不是我们定性思维认为的UIViewController,
    而是宏观的表示视图控制者,那我们倒是可以把其看成一个视图控制者,它可以控制多个视图控制器,比如TabbarController
    那样的感觉。

    Can we use one tableview with two different datasources? How you will achieve this?

    一个tableView是否可以关联两个不同的数据源?你会怎么处理?
    答案:首先我们从代码来看,数据源如何关联上的,其实是在数据源关联的代理方法里实现的。
    因此我们并不关心如何去关联他,他怎么关联上,方法只是让我返回根据自己的需要去设置如相关的数据源。
    因此,我觉得可以设置多个数据源啊,但是有个问题是,你这是想干嘛呢?想让列表如何显示,不同的数据源分区块显示?

    id、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就是实现方法。

    层和UIView的区别是什么?

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

    GCD为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];
    });

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

    可扩展标记语言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 asamplestring。这好比是将起始和结束标签看作是数学中的左右括号:在没有关闭所有的内部括号之前,是不能关闭外面的括号的。
    4 所有的特性都必须有值。
    5 所有的特性都必须在值的周围加上双引号。

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

    ASIDownloadCache 设置下载缓存

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

    相关文章

      网友评论

        本文标题:

        本文链接:https://www.haomeiwen.com/subject/zgjgjxtx.html