Runtime系列2之-类与对象的操作函数
前言
- 根据runtime的两大作用,上一章我们讲的是他的封装作用,即类和对象的实质是什么,下面这几篇文章就要将他的翻译作用了.
- 说到翻译,无非就是把OC的代码翻译成runtime对应的代码,OC的代码也就是创建/修改/使用—-类/对象/实例/属性/方法/协议这些操作了.由此观之Runtime也必然提供了这些与之对应的方法.
- 下面本章我们先分析,专门针对类与对象的操作函数.
- runtime提供了大量的函数来操作类与对象。类的操作方法大部分是以
class_为前缀的，而对象的操作方法大部分是以objc_或object_为前缀。下面我们将根据这些方法的用途来分类讨论这些方法的使用。 - 本章知识主线:
- 如何通过runtime提供的函数创建一个类和对象
- 通过runtime函数来操作这个类,比如:添加/获取方法等
- 通过runtime函数类操作创建的对象,比如:copy/销毁/获取对象的成员/属性值等
创建类和对象操作函数
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函数:- 如果我们要创建一个根类，则
superclass指定为Nil。extraBytes通常指定为0，该参数是分配给类和元类对象尾部的索引ivars的字节数。 - 为了创建一个新类，我们需要调用
objc_allocateClassPair。然后使用诸如class_addMethod，class_addIvar等函数来为新创建的类添加方法、实例变量和属性等。完成这些后，我们需要调用objc_registerClassPair函数来注册类，之后这个新类就可以在程序中使用了。 - 实例方法和实例变量应该添加到类自身上，而类方法应该添加到类的元类上。
- 如果我们要创建一个根类，则
- objc_disposeClassPair函数:
- 用于销毁一个类，不过需要注意的是，如果程序运行中还存在类或其子类的实例，则不能调用针对类调用该方法。
动态创建对象
-
动态创建对象的函数如下：
// 创建类实例 id class_createInstance ( Class cls, size_t extraBytes ); // 在指定位置创建类实例 id objc_constructInstance ( Class cls, void *bytes ); // 销毁类实例 void * objc_destructInstance ( id obj );class_createInstance函数：- 创建实例时，会在默认的内存区域为类分配内存。extraBytes参数表示分配的额外字节数。这些额外的字节可用于存储在类定义中所定义的实例变量之外的实例变量。
- 调用
class_createInstance的效果与+alloc方法类似。不过在使用class_createInstance时，我们需要确切的知道我们要用它来做什么。
objc_constructInstance函数：- 在指定的位置(bytes)创建类实例。
objc_destructInstance函数：- 销毁一个类的实例，但不会释放并移除任何与其相关的引用。
获取类定义
- 从上面的创建类我们可以知道,通过
objc_allocateClassPair方法来创建一个类后,还需要通过objc_registerClassPair方法来注册这个类.这是通过runtime来动态创建这个类. - 然而我们通过OC创建的一个类,Objective-C动态运行库会自动注册我们代码中定义的所有的类.
-
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体系的，所以在这些类上调用方法上，都应该先检测一下这个方法是否在这个类中实现。
- 获取类定义的方法有三个:
objc_lookUpClass,objc_getClass和objc_getRequiredClass。如果类在运行时未注册，则objc_lookUpClass会返回nil，而objc_getClass会调用类处理回调，并再次确认类是否注册，如果确认未注册，再返回nil。而objc_getRequiredClass函数的操作与objc_getClass相同，只不过如果没有找到类，则会杀死进程。
objc_getMetaClass函数：- 如果指定的类没有注册，则该函数会调用类处理回调，并再次确认类是否注册，如果确认未注册，再返回nil。不过，每个类定义都必须有一个有效的元类定义，所以这个函数总是会返回一个元类定义，不管它是否有效。
- objc_getClassList函数：
举例使用
-
上面讲了如何创建类,然后如何创建对象,代码举例: 动态创建一个TestClass类,继承自NSObject
- (void)createNewClass{ //1.创建一个TestClass类 Class newClass = objc_allocateClassPair([NSObject class], "TestClass", 0); //3.注册这个类 objc_registerClassPair(newClass); //4.通过这个类创建一个实例 id theObject = class_createInstance(newClass, sizeof(unsigned)); id instance = [theObject init]; //打印 NSLog(@"--对象为--%@--类为--%@--父类为--%@",instance,[instance class],[instance superclass]); }打印结果如下:
--对象为--<TestClass: 0x600000000a00>--类为--TestClass--父类为--NSObject
类相关操作函数
我们可以回过头去看看objc_class的定义，runtime提供的操作类的方法主要就是针对这个结构体中的各个字段的。下面我们分别介绍这一些的函数。并在最后以实例来演示这些函数的具体用法。
类名(name)
-
类名操作的函数主要有：
// 获取类的类名 const char * class_getName ( Class cls );- 对于class_getName函数，如果传入的cls为Nil，则返回一个字字符串。
父类(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。
- class_getSuperclass函数:
版本(version)
-
版本相关的操作包含以下函数：
// 获取版本号 int class_getVersion ( Class cls ); // 设置版本号 void class_setVersion ( Class cls, int version );
实例变量大小(instance_size)
-
实例变量大小操作的函数有：
// 获取实例大小 size_t class_getInstanceSize ( Class cls );
成员变量(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不支持类变量。注意，返回的列表不包含父类的成员变量和属性。
- class_addIvar函数:
- 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 );
// 为类添加属性
//这个可以给已经存在的类添加新的property，而且能够用过反射遍历到动态添加的属性。
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 );
这一种方法也是针对ivars来操作，不过只操作那些是属性的值。我们在后面介绍属性时会再遇到这些函数。
方法(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_addMethod函数:
- class_addMethod的实现会覆盖父类的方法实现，但不会取代本类中已存在的实现，如果本类中包含一个同名的实现，则函数会返回NO。如果要修改已存在实现，可以使用
method_setImplementation。 -
一个Objective-C方法是一个简单的C函数，它至少包含两个参数–self和_cmd。所以，我们的实现函数(IMP参数指向的函数)至少需要两个参数，如下所示：
void myMethodIMP(id self, SEL _cmd) { // implementation .... } - 与成员变量不同的是，我们可以为类动态添加方法，不管这个类是否已存在。
- 另外，参数types是一个描述传递给方法的参数类型的字符数组，这就涉及到类型编码，我们将在后面介绍。
- class_addMethod的实现会覆盖父类的方法实现，但不会取代本类中已存在的实现，如果本类中包含一个同名的实现，则函数会返回NO。如果要修改已存在实现，可以使用
- class_getInstanceMethod、class_getClassMethod函数
- 与class_copyMethodList不同的是，这两个函数都会去搜索父类的实现。
- class_copyMethodList函数:
- 返回包含所有实例方法的数组，如果需要获取类方法，则可以使用class_copyMethodList(object_getClass(cls), &count)(一个类的类方法是定义在元类里面)。
- 该列表不包含父类实现的方法。
- 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:方法来达到相同目的。
- 我们通常使用NSObject类的
协议(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()手动释放。
实例(对象)操作函数
实例操作函数主要是针对我们创建的实例对象的一系列操作函数，我们可以使用这组函数来从实例对象中获取我们想要的一些信息，如实例对象中变量的值。这组函数可以分为三小类：
针对整个对象进行操作的函数，这类函数包含
// 返回指定对象的一份拷贝
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);
针对对象实例变量进行操作的函数，这类函数包含：
// 修改类实例的实例变量的值
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快。
针对对象的类(类对象)进行操作的函数，这类函数包含：
// 返回给定对象的类名
const char * object_getClassName ( id obj );
// 返回对象的类
Class object_getClass ( id obj );
// 设置对象的类
Class object_setClass ( id obj, Class cls );
代码举例:
-
例1:类操作函数的使用
//MyClass.h文件 #import <Foundation/Foundation.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.m文件 #import "MyClass.h" #import <objc/runtime.h> int main(int argc, char * argv[]) { @autoreleasepool { //创建一个对象 MyClass *myClass = [[MyClass alloc] init]; unsigned int outCount = 0; //获取类对象 Class cls = myClass.class; // 类名 NSLog(@"类名===class name: %s", class_getName(cls)); // 父类 NSLog(@"父类名===super class name: %s", class_getName(class_getSuperclass(cls))); // 是否是元类 NSLog(@"是否为元类===MyClass is %@ a meta-class", (class_isMetaClass(cls) ? @"" : @"not")); //获得MyClass的元类 Class meta_class = objc_getMetaClass(class_getName(cls)); NSLog(@"MyClass的元类===%s's meta-class is %s", class_getName(cls), class_getName(meta_class)); // 变量实例大小 NSLog(@"变量实例大小===instance size: %zu", class_getInstanceSize(cls)); // 成员变量列表 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)); } // 属性操作 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)); } // 方法操作 //打印方法列表 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(); // 协议 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)); } return 0; }打印结果如下:
2017-11-29 14:45:57.336632+0800 RunTimeDemo[5366:311139] 类名===class name: MyClass 2017-11-29 14:45:57.337556+0800 RunTimeDemo[5366:311139] 父类名===super class name: NSObject 2017-11-29 14:45:57.337993+0800 RunTimeDemo[5366:311139] 是否为元类===MyClass is not a meta-class 2017-11-29 14:45:57.338176+0800 RunTimeDemo[5366:311139] MyClass的元类===MyClass's meta-class is MyClass 2017-11-29 14:45:57.338505+0800 RunTimeDemo[5366:311139] 变量实例大小===instance size: 48 2017-11-29 14:45:57.338651+0800 RunTimeDemo[5366:311139] 成员变量或属性===instance variable's name: _instance1 at index: 0 2017-11-29 14:45:57.339073+0800 RunTimeDemo[5366:311139] 成员变量或属性===instance variable's name: _instance2 at index: 1 2017-11-29 14:45:57.339800+0800 RunTimeDemo[5366:311139] 成员变量或属性===instance variable's name: _array at index: 2 2017-11-29 14:45:57.340316+0800 RunTimeDemo[5366:311139] 成员变量或属性===instance variable's name: _string at index: 3 2017-11-29 14:45:57.340860+0800 RunTimeDemo[5366:311139] 成员变量或属性===instance variable's name: _integer at index: 4 2017-11-29 14:45:57.341044+0800 RunTimeDemo[5366:311139] 成员变量是===instace variable _string 2017-11-29 14:45:57.341357+0800 RunTimeDemo[5366:311139] 属性有===property's name: integer 2017-11-29 14:45:57.341661+0800 RunTimeDemo[5366:311139] 属性有===property's name: array 2017-11-29 14:45:57.342069+0800 RunTimeDemo[5366:311139] 属性有===property's name: string 2017-11-29 14:45:57.342285+0800 RunTimeDemo[5366:311139] 属性为===property array 2017-11-29 14:45:57.342667+0800 RunTimeDemo[5366:311139] 方法有===method's signature: method1 2017-11-29 14:45:57.343139+0800 RunTimeDemo[5366:311139] 方法有===method's signature: method2 2017-11-29 14:45:57.343365+0800 RunTimeDemo[5366:311139] 方法有===method's signature: method3WithArg1:arg2: 2017-11-29 14:45:57.343777+0800 RunTimeDemo[5366:311139] 方法有===method's signature: integer 2017-11-29 14:45:57.344067+0800 RunTimeDemo[5366:311139] 方法有===method's signature: setInteger: 2017-11-29 14:45:57.344317+0800 RunTimeDemo[5366:311139] 方法有===method's signature: setArray: 2017-11-29 14:45:57.344739+0800 RunTimeDemo[5366:311139] 方法有===method's signature: .cxx_destruct 2017-11-29 14:45:57.344914+0800 RunTimeDemo[5366:311139] 方法有===method's signature: setString: 2017-11-29 14:45:57.345212+0800 RunTimeDemo[5366:311139] 方法有===method's signature: array 2017-11-29 14:45:57.345438+0800 RunTimeDemo[5366:311139] 方法有===method's signature: string 2017-11-29 14:45:57.345620+0800 RunTimeDemo[5366:311139] 对象方法===method method1 2017-11-29 14:45:57.345909+0800 RunTimeDemo[5366:311139] 类方法===class method : classMethod1 2017-11-29 14:45:57.346134+0800 RunTimeDemo[5366:311139] 是否实现某个方法===MyClass is responsd to selector: method3WithArg1:arg2: 2017-11-29 14:45:57.346321+0800 RunTimeDemo[5366:311139] call method method1 2017-11-29 14:45:57.346578+0800 RunTimeDemo[5366:311139] 协议名称为===protocol name: NSCopying 2017-11-29 14:45:57.347375+0800 RunTimeDemo[5366:311139] 协议名称为===protocol name: NSCoding 2017-11-29 14:45:57.348081+0800 RunTimeDemo[5366:311139] 是否实现协议===MyClass is responsed to protocol NSCoding -
例2:动态创建一个对象并给其添加一个方法
#import <Foundation/Foundation.h> @interface Test : NSObject + (void)ex_registerClassPair; @end #import <objc/runtime.h> #import "Test.h" 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 { //1.创建一个类 Class newClass = objc_allocateClassPair([NSError class], "TestClass", 0); //2.0给类添加一个方法 class_addMethod(newClass, @selector(testMetaClass), (IMP)TestMetaClass, "v@:"); //2.1 给这个类添加一个成员变量 class_addIvar(newClass, "_ivar1", sizeof(NSString *), log(sizeof(NSString *)), "i"); //2.2 给这个类添加一个属性 //给这个类设置属性特征 objc_property_attribute_t type = {"T", "@\"NSString\""}; // C = copy objc_property_attribute_t ownership0 = { "C", "" }; //N = nonatomic objc_property_attribute_t ownership1 = { "N", "" }; //V = variable name objc_property_attribute_t backingivar = { "V", "_ivar1"}; objc_property_attribute_t attrs[] = {type, ownership0,ownership1, backingivar}; class_addProperty(newClass, "ivar1", attrs, 4); //3.注册这个类 objc_registerClassPair(newClass); //4.通过这个类创建一个实例 id theObject = class_createInstance(newClass, sizeof(unsigned)); id instance = [theObject initWithDomain:@"some domain" code:0 userInfo:nil]; NSLog(@"-----%@",instance); //5.实例调用这个方法 [instance performSelector:@selector(testMetaClass)]; } @end打印结果:
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我们在for循环中，我们通过objc_getClass来获取对象的isa，并将其打印出来，依此一直回溯到NSObject的meta-class。分析打印结果，可以看到最后指针指向的地址是0x0，即NSObject的meta-class的类地址。