runtime 是OC底层的一套C语言库,那么些运维时系统即

Objective-C言语是一门动态语言,它将许多静态语言在编写翻译和链接时代做的事放到了运营时来拍卖。那种动态语言的优势在于:大家写代码时更具灵活性,如大家能够把新闻转载给大家想要的对象,或许私自沟通一个措施的贯彻等。

什么是runtime?

runtime 是OC底层的一套C语言库
(<objc/runtime.h>),基本上是用C和汇编写的,那几个库使得OC具有了面向对象的力量。runtime做的先头正是加载类的音信,举行艺术的散发和转账之类的。

那种特征意味着Objective-C不仅供给3个编译器,还索要1个运作时系统来执行编写翻译的代码。对于Objective-C来说,那几个运转时系统就像是一个操作系统一样:它让抱有的劳作得以健康的运营。那一个运营时系统即Objc RuntimeObjc Runtime实则是八个Runtime库,它基本上是用C和汇编写的,那么些库使得C语言有了面向对象的力量。

类与指标的原形

Runtime库重要做下边几件事:

壹 、封装:在那些库中,对象能够用C语言中的结构体表示,而艺术可以用C函数来落到实处,别的再添加了一些外加的特色。那些结构体和函数被runtime函数封装后,我们就足以在程序运转时成立,检查,修改类、对象和它们的艺术了。
二 、找出主意的终极实施代码:当程序执行[object doSomething]时,会向音信接收者(object)发送一条新闻(doSomething),runtime会依照音信接收者是还是不是能响应该音讯而做出分歧的反应。那将在后头详细介绍。

Objective-C
runtime当下有七个版本:Modern runtimeLegacy runtimeModern Runtime覆盖了64位的Mac OS X Apps,还有iOS AppsLegacy Runtime是早期用来给叁12位
Mac OS X Apps 用的,也便是足以不用管正是了。

在这一多元小说中,我们将介绍runtime的基本工作原理,以及如何运用它让大家的主次变得进一步灵敏。在本文中,大家先来介绍一下类与指标,那是面向对象的底蕴,大家看看在Runtime中,类是怎么着兑现的。

class

Objective-C类是由Class类型来表示的,它实在是多少个指向objc_class结构体的指针。定义如下:

typedef struct objc_class *Class;

查看objc/runtime.h中objc_class结构体的定义如下:

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class super_class                       OBJC2_UNAVAILABLE;  // 父类
    const char *name                        OBJC2_UNAVAILABLE;  // 类名
    long version                            OBJC2_UNAVAILABLE;  // 类的版本信息,默认为0
    long info                               OBJC2_UNAVAILABLE;  // 类信息,供运行期使用的一些位标识
    long instance_size                      OBJC2_UNAVAILABLE;  // 该类的实例变量大小
    struct objc_ivar_list *ivars            OBJC2_UNAVAILABLE;  // 该类的成员变量链表
    struct objc_method_list **methodLists   OBJC2_UNAVAILABLE;  // 方法定义的链表
    struct objc_cache *cache                OBJC2_UNAVAILABLE;  // 方法缓存
    struct objc_protocol_list *protocols    OBJC2_UNAVAILABLE;  // 协议链表
#endif

} OBJC2_UNAVAILABLE;

在上述objc_class结构体定义中,大家最首要关注之下多少个字段:

  1. isa:
    在OC中,类本人也是贰个指标,类的isa指针指向metaClass(元类),而实例对象的isa指针指向类。
  2. super_class: isa用于自省鲜明所属类,super_class明显继续关系
    。所以super_class指向该类的父类,假如此类已经是最顶层的根类(如NSObject或NSProxy),则super_class为NULL。
  3. cache:
    用于缓存近期使用的法子。二个接收者对象收取到贰个信息时,它会依据isa指针去探寻能够响应那个音信的目的。在事实上行使中,那几个指标只有一些方法是常用的,很多办法其实很少用恐怕根本用不上。那种景色下,假设每趟新闻来时,大家都以methodLists中遍历一次,质量势必很差。那时,cache就派上用场了。在大家每一次调用过3个方法后,那个主意就会被缓存到cache列表中,下次调用的时候runtime就会事先去cache中找找,假使cache没有,才去methodLists中检索方法。那样,对于那2个常常使用的法门的调用,但压实了调用的频率。
  4. version:
    使用这几个字段来提供类的版本消息。那对于指标的种类化分外有用,它能够让大家识别出区别类定义版本中实例变量布局的改动。

类与目的基础数据结构

类的实例的构造体 objc_object

struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

typedef struct objc_object *id;

其一结构体唯有三个字段,即指向其类的isa指针。向多个OC实例对象发送音讯时,runtime库依据那几个实例对象的isa指针找到该实例对象所属的类,runtime库会在类的措施列表及父类的艺术列表中去摸索与消息对应的selector指向的不二法门,找到后即运转那么些主意。

当创造某些类的实例对象时,分配的内部存款和储蓄器包涵一个objc_object结构体,然后是此类到父类直到根类的成员变量数据。NSObject类的alloc和allocWithZone:方法应用函数class_createInstance来创建objc_object结构体。

另外,常见的id花色,它是贰个objc_object结构类型的指针。它的存在能够让大家兑现类似于C++中泛型的有个别操作。该类型的对象能够变换为此外一种对象,有点类似于C语言中void
*指针类型的效用。

Class

Objective-C类是由Class花色来表示的,它其实是贰个针对objc_class结构体的指针。它的概念如下:

1  typedef struct objc_class *Class;

查看objc/runtime.hobjc_class结构体的定义如下:

1  struct objc_class {
2
3      Class isa  OBJC_ISA_AVAILABILITY;
4
5   #if !__OBJC2__
6      Class super_class                       OBJC2_UNAVAILABLE;   // 父类
7      const char *name                         OBJC2_UNAVAILABLE;  // 类名
8      long version                             OBJC2_UNAVAILABLE;  // 类的版本信息,默认为0
9      long info                                OBJC2_UNAVAILABLE;  // 类信息,供运行期使用的一些位标识
10     long instance_size                       OBJC2_UNAVAILABLE;  // 该类的实例变量大小
11     struct objc_ivar_list *ivars             OBJC2_UNAVAILABLE;  // 该类的成员变量链表
12     struct objc_method_list **methodLists    OBJC2_UNAVAILABLE;  // 方法定义的链表
13     struct objc_cache *cache                 OBJC2_UNAVAILABLE;  // 方法缓存
14     struct objc_protocol_list *protocols     OBJC2_UNAVAILABLE;  // 协议链表
15
16  #endif
17  } OBJC2_UNAVAILABLE;

在那么些概念中,下边多少个字段是大家感兴趣的

isa:须要留意的是在Objective-C中,全数的类本人也是2个指标,那一个目标的Class里面也有叁个isa指针,它指向metaClass(元类),大家会在后头介绍它。
super_class:指向该类的父类,即使此类已经是最顶层的根类(如NSObjectNSProxy),则super_class为NULL。
cache:用于缓存方今应用的艺术。二个接收者对象吸收到一个信息时,它会基于isa指针去摸索能够响应那些新闻的对象。在实质上运用中,那么些目的只有一些艺术是常用的,很多方式其实很少用或许根本用不上。这种气象下,若是每一趟音信来时,大家都以methodLists中遍历1回,质量势必很差。那时,cache就派上用场了。在大家每趟调用过一个措施后,那些格局就会被缓存到cache列表中,下次调用的时候runtime就会优先去cache中查找,如果cache没有,才去methodLists中寻觅方法。那样,对于那多少个常常选择的艺术的调用,但增进了调用的频率。
version:大家可以运用这一个字段来提供类的版本音信。那对于目的的体系化卓殊有用,它可是让我们识别出分化类定义版本中实例变量布局的更改。
针对cache,大家用上面例子来验证其实施进度:

1   NSArray *array = [[NSArray alloc] init];
2   其流程是:
3   1. `[NSArray alloc]`先被执行。因为NSArray没有`+alloc`方法,于是去父类NSObject去查找。
4   2. 检测NSObject是否响应`+alloc`方法,发现响应,于是检测NSArray类,并根据其所需的内存空间大小开始分配内存空间,然后把`isa`指针指向NSArray类。同时,`+alloc`也被加进cache列表里面。
5   3. 接着,执行`-init`方法,如果NSArray响应该方法,则直接将其加入`cache`;如果不响应,则去父类查找。
6   4. 在后期的操作中,如果再以`[[NSArray alloc] init]`这种方式来创建数组,则会直接从cache中取出相应的方法,直接调用。
7   ### objc_object与id
8   `objc_object`是表示一个类的实例的结构体,它的定义如下(`objc/objc.h`):
9    objc
10   struct objc_object {
11       Class isa  OBJC_ISA_AVAILABILITY;
12   };
13
14   typedef struct objc_object *id;

可以看到,那么些结构体只有3个字体,即指向其类的isa指针。这样,当大家向1个Objective-C目的发送音信时,运维时库会依照实例对象的isa指针找到这几个实例对象所属的类。Runtime库会在类的不二法门列表及父类的不二法门列表中去探寻与音讯对应的selector本着的法子。找到后即运转那几个办法。

当创制2个特定类的实例对象时,分配的内部存款和储蓄器包括八个objc_object数据结构,然后是类的实例变量的数目。NSObject类的allocallocWithZone:措施运用函数class_createInstance来创建objc_object数据结构。

其它还有我们广大的id,它是1个objc_object组织类型的指针。它的留存能够让大家兑现类似于C++中泛型的片段操作。该类型的目的可以转换为其它一种对象,有点类似于C语言中void *指针类型的效果。

元类(Meta Class)

在上头我们关系,全体的类自己也是八个目的,我们得以向那一个目的发送音讯(即调用类方法)。如:

NSArray *array = [NSArray array];

+array新闻发送给了NSArray类,而那些NSArray也是贰个对象,既然是目的,那么它也有二个objc_object结构体,该协会体内含有3个isa指针,指向该指标所属的类。那么这几个就有一个题材了,NSArray对象自笔者正是三个类,那里的isa指针指向哪些啊?不能够指向她协调吧?为了调用+array方法,那些类的isa指针必须指向一个带有那几个类方法的一个objc_class结构体。那就引出了meta-class(元类)的定义。
当大家向二个指标发送消息时,runtime会在那几个指标所属的这一个类的办法列表中查找方法;而向一个类发送消息时,会在这一个类的meta-class的主意列表中检索。

meta-class之所以重要,是因为它存款和储蓄着一个类的全部类方法。每一种类都会有1个独自的meta-class,因为各个类的类形式基本不容许完全相同。

objc_cache

地方提到了objc_class结构体中的cache字段,它用于缓存调用过的艺术。那个字段是3个针对objc_cache结构体的指针,其定义如下:

1   struct objc_cache {
2
3       unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
4       unsigned int occupied                                    OBJC2_UNAVAILABLE;
5       Method buckets[1]                                        OBJC2_UNAVAILABLE;
6
7   }; 

该结构体的字段描述如下:

mask:四个整数,钦赐分配的缓存bucket的总额。在艺术寻找进度中,Objective-C runtime运用这一个字段来规定伊始线性查找数组的目录地方。指向方法selector的指针与该字段做一个AND位操作(index = (mask & selector))。这能够看成二个简易的hash散列算法。
occupied:一个整数,钦点实际占用的缓存bucket的总数。
buckets:指向Method数据结构指针的数组。那几个数组可能包蕴不抢先mask+1个成分。需求留意的是,指针可能是NULL,表示那一个缓存bucket尚无被占据,别的被占据的bucket莫不是不总是的。这一个数组大概会趁机岁月而抓牢。

类与对象相关的操作函数

runtime提供了多量的函数来操作类与目的。类的操作方法半数以上是以class为前缀的,而目的的操作方法超越三分之一是以objc或object_为前缀。上边咱们将基于那些方法的用途来分类钻探这个办法的使用。

元类(Meta Class)

在上头我们关系,全体的类本身也是一个目标,大家得以向这几个目标发送音讯(即调用类方法)。如:

1   NSArray *array = [NSArray array];

其一例子中,+array音讯发送给了NSArray类,而以此NSArray也是多个指标。既然是目标,那么它也是三个objc_object指南针,它涵盖2个指向其类的一个isa指针。那么这些就有3个标题了,这么些isa指南针指向哪些呢?为了调用+array措施,这一个类的isa指针必须指向1个带有那些类形式的叁个objc_class结构体。那就引出了meta-class的概念

    meta-class是一个类对象的类。

当我们向二个目的发送新闻时,runtime会在这么些目的所属的那几个类的办法列表中搜寻方法;而向一个类发送音讯时,会在那个类的meta-class的章程列表中检索。

meta-class为此主要,是因为它存款和储蓄着二个类的全部类方法。种种类都会有二个独门的meta-class,因为各类类的类格局基本不也许完全相同。

再深远一下,meta-class也是三个类,也能够向它发送二个音讯,那么它的isa又是指向哪些吗?为了不让那种布局无限延伸下去,Objective-C的设计者让具有的meta-class的isa指向基类的meta-class,以此作为它们的所属类。即,任何NSObject持续连串下的meta-class都使用NSObject的meta-class用作家组织调的所属类,而基类的meta-class的isa指针是指向它自个儿。那样就形成了3个周密的闭环。

透过地点的描述,再拉长对objc_class结构体中super_class指南针的解析,我们就足以形容出类及相应meta-class类的二个持续种类了

对于NSObject继续种类来说,其实例方法对系统中的全部实例、类和meta-class都以卓有成效的;而类措施对于体系内的富有类和meta-class都是行得通的。

讲了这么多,我们还是来写个例子吗:

void TestMetaClass(id self, SEL _cmd) {

    NSLog(@"This objcet is %p", self);
    NSLog(@"Class is %@, super class is %@", [self class], [self superclass]);

    Class currentClass = [self class];
    for (int i = 0; i < 4; i++) {
        NSLog(@"Following the isa pointer %d times gives %p", i, currentClass);
        currentClass = objc_getClass((__bridge void *)currentClass);
    }

    NSLog(@"NSObject's class is %p", [NSObject class]);
    NSLog(@"NSObject's meta class is %p", objc_getClass((__bridge void *)[NSObject class]));
}

#pragma mark -
@implementation Test

- (void)ex_registerClassPair {

    Class newClass = objc_allocateClassPair([NSError class], "TestClass", 0);
    class_addMethod(newClass, @selector(testMetaClass), (IMP)TestMetaClass, "v@:");
    objc_registerClassPair(newClass);

    id instance = [[newClass alloc] initWithDomain:@"some domain" code:0 userInfo:nil];
    [instance performSelector:@selector(testMetaClass)];
}

@end

那个事例是在运转时创设了三个NSError的子类TestClass,然后为这些子类添加二个艺术testMetaClass,那一个法子的贯彻是TestMetaClass函数。

运作后,打字与印刷结果是

2014-10-20 22:57:07.352 mountain[1303:41490] This objcet is 0x7a6e22b0
2014-10-20 22:57:07.353 mountain[1303:41490] Class is TestStringClass, super class is NSError
2014-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 0 times gives 0x7a6e21b0
2014-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 1 times gives 0x0
2014-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 2 times gives 0x0
2014-10-20 22:57:07.353 mountain[1303:41490] Following the isa pointer 3 times gives 0x0
2014-10-20 22:57:07.353 mountain[1303:41490] NSObject's class is 0xe10000
2014-10-20 22:57:07.354 mountain[1303:41490] NSObject's meta class is 0x0

大家在for循环中,大家透过objc_getClass来取得对象的isa,并将其打字与印刷出来,依此一直回溯到NSObjectmeta-class。分析打字与印刷结果,能够看来最终指针指向的地点是0x0,即NSObjectmeta-class的类地点。

那里须求小心的是:我们在3个类对象调用class方法是无力回天获取meta-class,它只是再次回到类而已。

类相关操作函数

观察objc_class的概念,runtime提供的操作类的法门重要正是对准那一个结构体中的各样字段的。

(1) 类名(name)

  // 获取类的类名
const char * class_getName ( Class cls );

对于class_getName函数,要是传入的cls为Nil,则赶回四个空字符串。

(2) 父类(super_class)和元类(meta-class)

// 获取类的父类
Class class_getSuperclass ( Class cls );

// 判断给定的Class是否是一个元类
BOOL class_isMetaClass ( Class cls );

class_getSuperclass函数,当cls为Nil或许cls为根类时,重返Nil。不过普通大家得以行使NSObject类的superclass方法来实现相同的指标。
class_isMetaClass函数,假若是cls是元类,则赶回YES;倘使否或然传播的cls为Nil,则赶回NO。

(3) 实例变量大小(instance_size)

// 获取实例大小
size_t class_getInstanceSize ( Class cls );

.
(4) 成员变量(ivars)及质量

在objc_class中,全数的积极分子变量、属性的音信是放在链表ivars中的。ivars是三个数组,数组中每个成分是指向Ivar(变量新闻)的指针。runtime提供了丰富的函数来操作这一字段。

// 获取类中指定名称实例成员变量的信息
Ivar class_getInstanceVariable ( Class cls, const char *name );

// 获取类成员变量的信息
Ivar class_getClassVariable ( Class cls, const char *name );

// 添加成员变量
BOOL class_addIvar ( Class cls, const char *name, size_t size, uint8_t alignment, const char *types );

// 获取整个成员变量列表
Ivar * class_copyIvarList ( Class cls, unsigned int *outCount );

class_getInstanceVariable函数,它回到二个对准包罗name钦点的积极分子变量音讯的objc_ivar结构体的指针(Ivar)。

class_getClassVariable函数,近日从未有过找到关于Objective-C中类变量的音讯,一般认为Objective-C不扶助类变量。注意,再次来到的列表不分包父类的成员变量和总体性。

Objective-C不援助往已存在的类中添加实例变量,由此无论是是系统库提供的提供的类,依旧大家自定义的类,都心有余而力不足动态增加成员变量。但一旦我们透过运维时来成立一个类的话,又应当怎么给它添加成员变量呢?那时大家就能够使用class_addIvar函数了。不过要求留意的是,这几个措施只可以在objc_allocateClassPair函数与objc_registerClassPair之间调用。另外,这么些类也无法是元类。成员变量的按字节最小对齐量是1<<alignment。那有赖于ivar的门类和机械的架构。若是变量的项目是指针类型,则传递log2(sizeof(pointer_type))。

class_copyIvarList函数,它回到叁个对准成员变量音信的数组,数组中每种成分是指向该成员变量信息的objc_ivar结构体的指针。那个数组不带有在父类中宣示的变量。outCount指针重临数组的深浅。必要小心的是,大家亟须选拔free()来刑释那些数组。

// 获取指定的属性
objc_property_t class_getProperty ( Class cls, const char *name );

// 获取属性列表
objc_property_t * class_copyPropertyList ( Class cls, unsigned int *outCount );

// 为类添加属性
BOOL class_addProperty ( Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount );

// 替换类的属性
void class_replaceProperty ( Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount );

(5) 方法(methodLists)
艺术操作首要有以下函数:

// 添加方法
BOOL class_addMethod ( Class cls, SEL name, IMP imp, const char *types );

// 获取实例方法
Method class_getInstanceMethod ( Class cls, SEL name );

// 获取类方法
Method class_getClassMethod ( Class cls, SEL name );

// 获取所有方法的数组
Method * class_copyMethodList ( Class cls, unsigned int *outCount );

// 替代方法的实现
IMP class_replaceMethod ( Class cls, SEL name, IMP imp, const char *types );

// 返回方法的具体实现
IMP class_getMethodImplementation ( Class cls, SEL name );
IMP class_getMethodImplementation_stret ( Class cls, SEL name );

// 类实例是否响应指定的selector
BOOL class_respondsToSelector ( Class cls, SEL sel );

我们得以为类动态增进方法,不管那些类是还是不是已存在。
class_getInstanceMethod
class_getClassMethod函数,与class_copyMethodList分化的是,那七个函数都会去追寻父类的贯彻。

class_copyMethodList函数,重回包涵全体实例方法的数组,要是须求得到类措施,则能够采取class_copyMethodList(object_getClass(cls),
&count)(1个类的实例方法是概念在元类里面)。该列表不带有父类达成的格局。outCount参数再次回到方法的个数。在取获得列表后,我们必要利用free()方法来刑释它。

class_replaceMethod函数,该函数的行为能够分成三种:倘使类中不设有name钦点的措施,则类似于class_addMethod函数一样会助长方法;如果类中已存在name内定的法子,则类似于method_setImplementation一样替代原方法的贯彻。

class_getMethodImplementation函数,该函数在向类实例发送消息时会被调用,并回到三个针对性方法实现函数的指针。那么些函数会比method_getImplementation(class_getInstanceMethod(cls,
name))更快。重回的函数指针大概是1个指向runtime内部的函数,而不必然是方法的骨子里贯彻。例如,假诺类实例不能响应selector,则赶回的函数指针将是运营时消息转运载飞机制的一局地。

class_respondsToSelector函数,我们平时采纳NSObject类的respondsToSelector:或instancesRespondToSelector:方法来完结平等指标。

(6) 协议(objc_protocol_list)
探究相关的操作包括以下函数:

// 添加协议
BOOL class_addProtocol ( Class cls, Protocol *protocol );

// 返回类是否实现指定的协议
BOOL class_conformsToProtocol ( Class cls, Protocol *protocol );

// 返回类实现的协议列表
Protocol * class_copyProtocolList ( Class cls, unsigned int *outCount );

class_conformsToProtocol函数能够选拔NSObject类的conformsToProtocol:方法来取代。

class_copyProtocolList函数重临的是三个数组,在选用后大家须要动用free()手动释放。

类与对象操作函数

runtime提供了汪洋的函数来操作类与指标。类的操作方法大多数是以class_为前缀的,而目的的操作方法大部分是以objc_或object_为前缀。上面大家将依据那个艺术的用处来分类研讨这么些模式的运用。

实例相关的操作函数

实例操作函数根本是针对性大家创立的实例对象的一多元操作函数,大家得以行使那组函数来从实例对象中得到大家想要的一些新闻,如实例对象中变量的值。那组函数能够分成三小类:

(1) 对实例对象实行操作的函数

// 返回指定对象的一份拷贝
id object_copy ( id obj, size_t size );

// 释放指定对象占用的内存
id object_dispose ( id obj );

有诸如此类一种现象,若是大家有类A和类B,且类B是类A的子类。类B通过抬高级中学一年级些卓绝的性质来扩充类A。以后大家创建了多个A类的实例对象,并期待在运营时将以此目的转换为B类的实例对象,这样能够添加数据到B类的质量中。这种景况下,我们没有章程直接转换,因为B类的实例会比A类的实例更大,没有丰裕的上空来放置对象。此时,大家就要以使用上述多少个函数来处理那种地方,如下代码所示:

NSObject *a = [[NSObject alloc] init];
id newB = object_copy(a, class_getInstanceSize(MyClass.class));
object_setClass(newB, MyClass.class);
object_dispose(a);

(2) 操作对象的实例变量

// 修改类实例的实例变量的值
Ivar object_setInstanceVariable ( id obj, const char *name, void *value );

// 获取对象实例变量的值
Ivar object_getInstanceVariable ( id obj, const char *name, void **outValue );

// 返回指向给定对象分配的任何额外字节的指针
void * object_getIndexedIvars ( id obj );

// 返回对象中实例变量的值
id object_getIvar ( id obj, Ivar ivar );

// 设置对象中实例变量的值
void object_setIvar ( id obj, Ivar ivar, id value );

若是实例变量的Ivar已经精通,那么调用object_getIvar会比object_getInstanceVariable函数快,相同情形下,object_setIvar也比object_setInstanceVariable快。

(3) 操作对象的类

// 返回给定对象的类名
const char * object_getClassName ( id obj );

// 返回对象的类
Class object_getClass ( id obj );

// 设置对象的类
Class object_setClass ( id obj, Class cls );

.
转发自: Objective-C Runtime
运转时之一:类与目的

类相关操作函数

大家得以回过头去探访objc_class
的定义,runtime提供的操作类的法门首要正是本着那一个结构体中的各种字段的。上边我们分别介绍这一部分的函数。并在终极以实例来演示那么些函数的切实可行用法。

类名(name)

类名操作的函数首要有:

1  // 获取类的类名
2  const char * class_getName ( Class cls );

对于class_getName函数,假如传入的cls为Nil,则赶回1个字字符串。

父类(super_class)和元类(meta-class)

父类和元类操作的函数主要有:

1   // 获取类的父类
2   Class class_getSuperclass ( Class cls );
3
4  // 判断给定的Class是否是一个元类
5   BOOL class_isMetaClass ( Class cls );
  • 1、class_getSuperclass函数,当cls为Nil恐怕cls为根类时,再次来到Nil。但是普通大家能够应用NSObject类的superclass方法来完毕相同的指标。
  • 2、class_isMetaClass函数,假设是cls是元类,则赶回YES;假如否或许传播的cls为Nil,则赶回NO。

实例变量大小(instance_size)

实例变量大小操作的函数有:

1   // 获取实例大小
2   size_t class_getInstanceSize ( Class cls );

成员变量(ivars)及品质

在objc_class中,全部的积极分子变量、属性的音信是放在链表ivars中的。ivars是贰个数组,数组中各样成分是指向Ivar(变量消息)的指针。runtime提供了增进的函数来操作这一字段。大体上得以分成以下几类:

1.成员变量操作函数,重要涵盖以下函数:

1   // 获取类中指定名称实例成员变量的信息
2   Ivar class_getInstanceVariable ( Class cls, const char *name );
3
4   // 获取类成员变量的信息
5   Ivar class_getClassVariable ( Class cls, const char *name );
6   
7   // 添加成员变量
8   BOOL class_addIvar ( Class cls, const char *name, size_t size, uint8_t alignment, const char *types );
9
10   // 获取整个成员变量列表
11   Ivar * class_copyIvarList ( Class cls, unsigned int *outCount );
  • class_getInstanceVariable函数,它回到一个对准包蕴name钦定的积极分子变量新闻的objc_ivar结构体的指针(Ivar)。

  • class_getClassVariable函数,如今并未找到有关Objective-C中类变量的消息,一般认为Objective-C不扶助类变量。注意,重回的列表不分包父类的分子变量和属性。

  • Objective-C不扶助往已存在的类中添加实例变量,因而不论是系统库提供的提供的类,依旧大家自定义的类,都心有余而力不足动态增进成员变量。但假设大家由此运行时来创立七个类的话,又应当怎样给它添加成员变量呢?那时大家就足以使用class_addIvar函数了。可是必要小心的是,这一个艺术只可以在objc_allocateClassPair函数与objc_registerClassPair之间调用。此外,那个类也无法是元类。成员变量的按字节最小对齐量是1<<alignment。那有赖于ivar的门类和机械和工具的架构。固然变量的项目是指针类型,则传递log2(sizeof(pointer_type))。

  • class_copyIvarList函数,它回到五个针对成员变量消息的数组,数组中种种成分是指向该成员变量音信的objc_ivar结构体的指针。那个数组不带有在父类中宣称的变量。outCount指针重返数组的轻重。要求专注的是,我们必须运用free()来刑释这么些数组。

2.属性操作函数,重要涵盖以下函数:

1    // 获取指定的属性
2    objc_property_t class_getProperty ( Class cls, const char *name );
3
4    // 获取属性列表
5    objc_property_t * class_copyPropertyList ( Class cls, unsigned int *outCount );
6
7    // 为类添加属性
8    BOOL class_addProperty ( Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount );
9
10   // 替换类的属性
11   void class_replaceProperty ( Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount );

这一种艺术也是针对性ivars来操作,不过只操作那么些是性质的值。大家在前边介绍属性时会再蒙受这几个函数。

3.在MAC OS X系统中,大家能够动用垃圾回收器。runtime提供了多少个函数来规定3个目的的内部存款和储蓄器区域是不是足以被垃圾回收器扫描,以拍卖strong/weak引用。这多少个函数定义如下:

1   const uint8_t * class_getIvarLayout ( Class cls );
2   void class_setIvarLayout ( Class cls, const uint8_t *layout );
3   const uint8_t * class_getWeakIvarLayout ( Class cls );
4   void class_setWeakIvarLayout ( Class cls, const uint8_t *layout );

但一般状态下,大家不须求去主动调用这一个艺术;在调用objc_registerClassPair时,会变动合理的布局。在此不详细介绍这么些函数。

方法(methodLists)

格局操作主要有以下函数:

1   // 添加方法
2   BOOL class_addMethod ( Class cls, SEL name, IMP imp, const char *types );
3   // 获取实例方法
4   Method class_getInstanceMethod ( Class cls, SEL name );
5   // 获取类方法
6   Method class_getClassMethod ( Class cls, SEL name );
7   // 获取所有方法的数组
8   Method * class_copyMethodList ( Class cls, unsigned int *outCount );
9   // 替代方法的实现
10  IMP class_replaceMethod ( Class cls, SEL name, IMP imp, const char *types );
11  // 返回方法的具体实现
12  IMP class_getMethodImplementation ( Class cls, SEL name );
13  IMP class_getMethodImplementation_stret ( Class cls, SEL name );
14  // 类实例是否响应指定的selector
15  BOOL class_respondsToSelector ( Class cls, SEL sel );

class_addMethod的兑现会覆盖父类的法门完成,但不会代替本类中已存在的落到实处,假如本类中包涵三个同名的实现,则函数会回来NO。即使要修改已存在贯彻,能够动用method_setImplementation。一个Objective-C格局是二个简短的C函数,它至少含有三个参数–self_cmd。所以,大家的兑现函数(IMP参数指向的函数)至少供给三个参数,如下所示:

1   void myMethodIMP(id self, SEL _cmd)
2   {
3        // implementation ....
4   }

与成员变量不一样的是,我们得以为类动态增加方法,不管这一个类是还是不是已存在。

另外,参数types是七个描述传递给艺术的参数类型的字符数组,这就关系到品种编码,大家将在后头介绍。

  • class_getInstanceMethodclass_getClassMethod函数,与class_copyMethodList不等的是,那多个函数都会去搜寻父类的兑现。

  • class_copyMethodList函数,重临包罗全部实例方法的数组,若是必要获得类格局,则足以选用class_copyMethodList(object_getClass(cls), &count)(3个类的实例方法是概念在元类里面)。该列表不包括父类完结的法门。outCount参数再次回到方法的个数。在获得到列表后,我们需求运用free()情势来刑满释放解除劳教它。

  • class_replaceMethod函数,该函数的行事能够分成三种:即使类中不设有name钦命的章程,则接近于class_addMethod函数一样会拉长方法;要是类中已存在name钦命的法子,则类似于method_setImplementation一样替代原方法的贯彻。

  • class_getMethodImplementation函数,该函数在向类实例发送新闻时会被调用,并再次回到二个针对方法达成函数的指针。这几个函数会比method_getImplementation(class_getInstanceMethod(cls, name))更快。再次来到的函数指针可能是三个指向runtime内部的函数,而不必然是艺术的实在落到实处。例如,假设类实例无法响应selector,则赶回的函数指针将是运作时音讯转运载飞机制的一某些。

  • class_respondsToSelector函数,大家一般选拔NSObject类的respondsToSelector:instancesRespondToSelector:艺术来达到同等指标。

协议(objc_protocol_list)

研讨相关的操作包涵以下函数:

1   // 添加协议
2   BOOL class_addProtocol ( Class cls, Protocol *protocol );
3
4   // 返回类是否实现指定的协议
5   BOOL class_conformsToProtocol ( Class cls, Protocol *protocol );
6
7   // 返回类实现的协议列表
8   Protocol * class_copyProtocolList ( Class cls, unsigned int *outCount );
  • class_conformsToProtocol函数能够动用NSObject类的conformsToProtocol:艺术来顶替。

  • class_copyProtocolList函数重回的是一个数组,在接纳后大家须求接纳free()手动释放。

版本(version)

本子相关的操作包蕴以下函数:

1   // 获取版本号
2   int class_getVersion ( Class cls );
3
4   // 设置版本号
5   void class_setVersion ( Class cls, int version );

其它

runtime还提供了多个函数来供CoreFoundation的tool-free bridging使用,即:

1   Class objc_getFutureClass ( const char *name );
2   void objc_setFutureClass ( Class cls, const char *name );

一般性大家不直接运用那多个函数。

实例(Example)

上边列举了多量类操作的函数,上边大家写个实例,来探望这几个函数的实例效果:

//-----------------------------------------------------------
// MyClass.h
@interface MyClass : NSObject <NSCopying, NSCoding>
@property (nonatomic, strong) NSArray *array;
@property (nonatomic, copy) NSString *string;
- (void)method1;
- (void)method2;
+ (void)classMethod1;
@end
//-----------------------------------------------------------
// MyClass.m
#import "MyClass.h"
@interface MyClass () {
    NSInteger       _instance1;
    NSString    *   _instance2;
}
@property (nonatomic, assign) NSUInteger integer;
- (void)method3WithArg1:(NSInteger)arg1 arg2:(NSString *)arg2;
@end
@implementation MyClass
+ (void)classMethod1 {
}
- (void)method1 {
    NSLog(@"call method method1");
}
- (void)method2 {
}
- (void)method3WithArg1:(NSInteger)arg1 arg2:(NSString *)arg2 {
    NSLog(@"arg1 : %ld, arg2 : %@", arg1, arg2);
}
@end
//-----------------------------------------------------------
// main.h
#import "MyClass.h"
#import "MySubClass.h"
#import <objc/runtime.h>
int main(int argc, const char * argv[]) {
    @autoreleasepool {

        MyClass *myClass = [[MyClass alloc] init];
        unsigned int outCount = 0;
        Class cls = myClass.class;
        // 类名
        NSLog(@"class name: %s", class_getName(cls));
        NSLog(@"==========================================================");
        // 父类
        NSLog(@"super class name: %s", class_getName(class_getSuperclass(cls)));
        NSLog(@"==========================================================");
        // 是否是元类
        NSLog(@"MyClass is %@ a meta-class", (class_isMetaClass(cls) ? @"" : @"not"));
        NSLog(@"==========================================================");
        Class meta_class = objc_getMetaClass(class_getName(cls));
        NSLog(@"%s's meta-class is %s", class_getName(cls), class_getName(meta_class));
        NSLog(@"==========================================================");
        // 变量实例大小
        NSLog(@"instance size: %zu", class_getInstanceSize(cls));
        NSLog(@"==========================================================");
        // 成员变量
        Ivar *ivars = class_copyIvarList(cls, &outCount);
        for (int i = 0; i < outCount; i++) {
            Ivar ivar = ivars[i];
            NSLog(@"instance variable's name: %s at index: %d", ivar_getName(ivar), i);
        }
        free(ivars);
        Ivar string = class_getInstanceVariable(cls, "_string");
        if (string != NULL) {
            NSLog(@"instace variable %s", ivar_getName(string));
        }
        NSLog(@"==========================================================");
        // 属性操作
        objc_property_t * properties = class_copyPropertyList(cls, &outCount);
        for (int i = 0; i < outCount; i++) {
            objc_property_t property = properties[i];
            NSLog(@"property's name: %s", property_getName(property));
        }
        free(properties);
        objc_property_t array = class_getProperty(cls, "array");
        if (array != NULL) {
            NSLog(@"property %s", property_getName(array));
        }
        NSLog(@"==========================================================");
        // 方法操作
        Method *methods = class_copyMethodList(cls, &outCount);
        for (int i = 0; i < outCount; i++) {
            Method method = methods[i];
            NSLog(@"method's signature: %s", method_getName(method));
        }
        free(methods);
        Method method1 = class_getInstanceMethod(cls, @selector(method1));
        if (method1 != NULL) {
            NSLog(@"method %s", method_getName(method1));
        }
        Method classMethod = class_getClassMethod(cls, @selector(classMethod1));
        if (classMethod != NULL) {
            NSLog(@"class method : %s", method_getName(classMethod));
        }
        NSLog(@"MyClass is%@ responsd to selector: method3WithArg1:arg2:", class_respondsToSelector(cls, @selector(method3WithArg1:arg2:)) ? @"" : @" not");
        IMP imp = class_getMethodImplementation(cls, @selector(method1));
        imp();
        NSLog(@"==========================================================");
        // 协议
        Protocol * __unsafe_unretained * protocols = class_copyProtocolList(cls, &outCount);
        Protocol * protocol;
        for (int i = 0; i < outCount; i++) {
            protocol = protocols[i];
            NSLog(@"protocol name: %s", protocol_getName(protocol));
        }
        NSLog(@"MyClass is%@ responsed to protocol %s", class_conformsToProtocol(cls, protocol) ? @"" : @" not", protocol_getName(protocol));
        NSLog(@"==========================================================");
    }
    return 0;
}

2014-10-22 19:41:37.452 RuntimeTest[3189:156810] class name: MyClass
2014-10-22 19:41:37.453 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.454 RuntimeTest[3189:156810] super class name: NSObject
2014-10-22 19:41:37.454 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.454 RuntimeTest[3189:156810] MyClass is not a meta-class
2014-10-22 19:41:37.454 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.454 RuntimeTest[3189:156810] MyClass's meta-class is MyClass
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] instance size: 48
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] instance variable's name: _instance1 at index: 0
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] instance variable's name: _instance2 at index: 1
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] instance variable's name: _array at index: 2
2014-10-22 19:41:37.455 RuntimeTest[3189:156810] instance variable's name: _string at index: 3
2014-10-22 19:41:37.463 RuntimeTest[3189:156810] instance variable's name: _integer at index: 4
2014-10-22 19:41:37.463 RuntimeTest[3189:156810] instace variable _string
2014-10-22 19:41:37.463 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.463 RuntimeTest[3189:156810] property's name: array
2014-10-22 19:41:37.463 RuntimeTest[3189:156810] property's name: string
2014-10-22 19:41:37.464 RuntimeTest[3189:156810] property's name: integer
2014-10-22 19:41:37.464 RuntimeTest[3189:156810] property array
2014-10-22 19:41:37.464 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.464 RuntimeTest[3189:156810] method's signature: method1
2014-10-22 19:41:37.464 RuntimeTest[3189:156810] method's signature: method2
2014-10-22 19:41:37.464 RuntimeTest[3189:156810] method's signature: method3WithArg1:arg2:
2014-10-22 19:41:37.465 RuntimeTest[3189:156810] method's signature: integer
2014-10-22 19:41:37.465 RuntimeTest[3189:156810] method's signature: setInteger:
2014-10-22 19:41:37.465 RuntimeTest[3189:156810] method's signature: array
2014-10-22 19:41:37.465 RuntimeTest[3189:156810] method's signature: string
2014-10-22 19:41:37.465 RuntimeTest[3189:156810] method's signature: setString:
2014-10-22 19:41:37.465 RuntimeTest[3189:156810] method's signature: setArray:
2014-10-22 19:41:37.466 RuntimeTest[3189:156810] method's signature: .cxx_destruct
2014-10-22 19:41:37.466 RuntimeTest[3189:156810] method method1
2014-10-22 19:41:37.466 RuntimeTest[3189:156810] class method : classMethod1
2014-10-22 19:41:37.466 RuntimeTest[3189:156810] MyClass is responsd to selector: method3WithArg1:arg2:
2014-10-22 19:41:37.467 RuntimeTest[3189:156810] call method method1
2014-10-22 19:41:37.467 RuntimeTest[3189:156810] ==========================================================
2014-10-22 19:41:37.467 RuntimeTest[3189:156810] protocol name: NSCopying
2014-10-22 19:41:37.467 RuntimeTest[3189:156810] protocol name: NSCoding
2014-10-22 19:41:37.467 RuntimeTest[3189:156810] MyClass is responsed to protocol NSCoding
2014-10-22 19:41:37.468 RuntimeTest[3189:156810] ==========================================================

动态创造类和对象

runtime的精锐之处在于它能在运转时创立类和目的。
动态####创建类
动态创立类涉及到以下多少个函数:

// 创建一个新类和元类
Class objc_allocateClassPair ( Class superclass, const char *name, size_t extraBytes );
// 销毁一个类及其相关联的类
void objc_disposeClassPair ( Class cls );
// 在应用中注册由objc_allocateClassPair创建的类
void objc_registerClassPair ( Class cls );
  • objc_allocateClassPair函数:如若大家要创建3个根类,则superclass钦点为Nil。extraBytes平常钦定为0,该参数是分配给类和元类对象尾部的索引ivars的字节数。

为了创建一个新类,我们供给调用objc_allocateClassPair。然后使用诸如class_addMethod,class_addIvar等函数来为新成立的类添加方法、实例变量和属性等。完结这一个后,大家须要调用objc_registerClassPair函数来注册类,之后那么些新类就能够在程序中运用了。

实例方法和实例变量应该加上到类本人上,而类措施应该加上到类的元类上。

  • objc_disposeClassPair函数用于销毁叁个类,可是供给小心的是,假若程序运转中还设有类或其子类的实例,则无法调用针对类调用该办法。
    在前头介绍元类时,大家曾经有接触到那多少个函数了,在此大家再举个实例来看看那多少个函数的施用。

Class cls = objc_allocateClassPair(MyClass.class, "MySubClass", 0);

class_addMethod(cls, @selector(submethod1), (IMP)imp_submethod1, "v@:");
class_replaceMethod(cls, @selector(method1), (IMP)imp_submethod1, "v@:");
class_addIvar(cls, "_ivar1", sizeof(NSString *), log(sizeof(NSString *)), "i");

objc_property_attribute_t type = {"T", "@\"NSString\""};
objc_property_attribute_t ownership = { "C", "" };
objc_property_attribute_t backingivar = { "V", "_ivar1"};
objc_property_attribute_t attrs[] = {type, ownership, backingivar};

class_addProperty(cls, "property2", attrs, 3);
objc_registerClassPair(cls);
id instance = [[cls alloc] init];
[instance performSelector:@selector(submethod1)];
[instance performSelector:@selector(method1)];

先后的出口如下:

2014-10-23 11:35:31.006 RuntimeTest[3800:66152] run sub method 1
2014-10-23 11:35:31.006 RuntimeTest[3800:66152] run sub method 1

动态成立对象

动态创设对象的函数如下:

// 创建类实例
id class_createInstance ( Class cls, size_t extraBytes );

// 在指定位置创建类实例
id objc_constructInstance ( Class cls, void *bytes );

// 销毁类实例
void * objc_destructInstance ( id obj );
  • class_createInstance函数:创设实例时,会在暗中认可的内部存款和储蓄器区域为类分配内部存款和储蓄器。extraBytes参数表示分配的额外字节数。这几个额外的字节可用来存款和储蓄在类定义中所定义的实例变量之外的实例变量。该函数在A讴歌ZDXC环境下不可能选用。

调用class_createInstance的法力与+alloc主意类似。可是在使用class_createInstance时,大家必要适量的明白大家要用它来做怎么着。在底下的例子中,咱们用NSString来测试一下该函数的实效:

id theObject = class_createInstance(NSString.class, sizeof(unsigned));

id str1 = [theObject init];
NSLog(@"%@", [str1 class]);

id str2 = [[NSString alloc] initWithString:@"test"];
NSLog(@"%@", [str2 class]);

出口的结果是

2014-10-23 12:46:50.781 RuntimeTest[4039:89088] NSString
2014-10-23 12:46:50.781 RuntimeTest[4039:89088] __NSCFConstantString

可以看出,使用class_createInstance函数获取的是NSString实例,而不是类簇中的私下认可占位符类__NSCFConstantString。

  • objc_constructInstance函数:在钦定的地点(bytes)创造类实例。

  • objc_destructInstance函数:销毁1个类的实例,但不会放出并移除任何与其有关的引用。

实例操作函数

实例操作函数根本是针对性大家创制的实例对象的一文山会海操作函数,大家得以行使那组函数来从实例对象中获得咱们想要的一对音讯,如实例对象中变量的值。那组函数能够分为三小类:

1.针对任何对象开始展览操作的函数,那类函数包括

// 返回指定对象的一份拷贝
id object_copy ( id obj, size_t size );

// 释放指定对象占用的内存
id object_dispose ( id obj );

有诸如此类一种现象,即使大家有类A和类B,且类B是类A的子类。类B通过抬高级中学一年级些十分的性质来扩展类A。未来大家创立了叁个A类的实例对象,并期待在运转时将那个指标转换为B类的实例对象,那样能够添加数据到B类的质量中。那种情形下,大家从没主意直接转换,因为B类的实例会比A类的实例更大,没有丰硕的上空来放置对象。此时,大家就要以使用上述多少个函数来拍卖那种场馆,如下代码所示:

NSObject *a = [[NSObject alloc] init];
id newB = object_copy(a, class_getInstanceSize(MyClass.class));
object_setClass(newB, MyClass.class);
object_dispose(a);

2.针对对象实例变量实行操作的函数,那类函数包蕴:

// 修改类实例的实例变量的值
Ivar object_setInstanceVariable ( id obj, const char *name, void *value );

// 获取对象实例变量的值
Ivar object_getInstanceVariable ( id obj, const char *name, void **outValue );

// 返回指向给定对象分配的任何额外字节的指针
void * object_getIndexedIvars ( id obj );

// 返回对象中实例变量的值
id object_getIvar ( id obj, Ivar ivar );

// 设置对象中实例变量的值
void object_setIvar ( id obj, Ivar ivar, id value );

设若实例变量的Ivar已经领悟,那么调用object_getIvar会比object_getInstanceVariable函数快,相同景况下,object_setIvar也比object_setInstanceVariable快。

3.针对性对象的类实行操作的函数,那类函数包蕴:

// 返回给定对象的类名
const char * object_getClassName ( id obj );

// 返回对象的类
Class object_getClass ( id obj );

// 设置对象的类
Class object_setClass ( id obj, Class cls );

收获类定义

Objective-C动态运营库会自动注册我们代码中定义的有着的类。大家也可以在运维时创设类定义并利用objc_addClass函数来注册它们。runtime提供了一多重函数来获得类定义相关的音讯,这么些函数首要不外乎:

// 获取已注册的类定义的列表
int objc_getClassList ( Class *buffer, int bufferCount );

// 创建并返回一个指向所有已注册类的指针列表
Class * objc_copyClassList ( unsigned int *outCount );

// 返回指定类的类定义
Class objc_lookUpClass ( const char *name );
Class objc_getClass ( const char *name );
Class objc_getRequiredClass ( const char *name );

// 返回指定类的元类
Class objc_getMetaClass ( const char *name );
  • objc_getClassList函数:获取已登记的类定义的列表。大家不能够若是从该函数中取得的类对象是持续自NSObject系统的,所以在那么些类上调用方法是,都应该先检查和测试一下那个办法是不是在这一个类中落到实处。

上面代码演示了该函数的用法:

int numClasses;
Class * classes = NULL;
numClasses = objc_getClassList(NULL, 0);
if (numClasses > 0) {
    classes = malloc(sizeof(Class) * numClasses);
    numClasses = objc_getClassList(classes, numClasses);
    NSLog(@"number of classes: %d", numClasses);
    for (int i = 0; i < numClasses; i++) {
        Class cls = classes[i];
        NSLog(@"class name: %s", class_getName(cls));
    }
    free(classes);
}

出口结果如下:

2014-10-23 16:20:52.589 RuntimeTest[8437:188589] number of classes: 1282
2014-10-23 16:20:52.589 RuntimeTest[8437:188589] class name: DDTokenRegexp
2014-10-23 16:20:52.590 RuntimeTest[8437:188589] class name: _NSMostCommonKoreanCharsKeySet
2014-10-23 16:20:52.590 RuntimeTest[8437:188589] class name: OS_xpc_dictionary
2014-10-23 16:20:52.590 RuntimeTest[8437:188589] class name: NSFileCoordinator
2014-10-23 16:20:52.590 RuntimeTest[8437:188589] class name: NSAssertionHandler
2014-10-23 16:20:52.590 RuntimeTest[8437:188589] class name: PFUbiquityTransactionLogMigrator
2014-10-23 16:20:52.591 RuntimeTest[8437:188589] class name: NSNotification
2014-10-23 16:20:52.591 RuntimeTest[8437:188589] class name: NSKeyValueNilSetEnumerator
2014-10-23 16:20:52.591 RuntimeTest[8437:188589] class name: OS_tcp_connection_tls_session
2014-10-23 16:20:52.591 RuntimeTest[8437:188589] class name: _PFRoutines
......还有大量输出
  • 获得类定义的主意有八个:objc_lookUpClass,
    objc_getClassobjc_getRequiredClass。借使类在运维时未注册,则objc_lookUpClass会返回nil,而objc_getClass会调用类处理回调,仁同一视复肯定类是或不是注册,假如承认未注册,再再次来到nil。而objc_getRequiredClass函数的操作与objc_getClass一致,只可是假诺没有找到类,则会杀死进度。

  • objc_getMetaClass函数:要是内定的类没有挂号,则该函数会调用类处理回调,等量齐观复肯定类是或不是注册,假诺确认未注册,再再次回到nil。然则,各样类定义都不能够不有1个实用的元类定义,所以那么些函数总是会回去3个元类定义,不管它是或不是管用。

小结

在这一章中大家介绍了Runtime运营时中与类和对象相关的数据结构,通过那一个数量函数,大家能够管窥Objective-C底层面向对象达成的片段音信。其余,通过添加的操作函数,能够灵活地对那些数量举行操作。

连带文章

Objective-C Runtime
运维时之二:成员变量与天性

Objective-C Runtime
运营时之三:方法与新闻

本文章转发自:南峰子的技能博客

相关文章