OC对象类型浅析

OC中对象类型的分类

OC中对象类型可以分为如下三类：

  • instance 实例对象
  • class 类对象
  • meta-class 元类对象

我们可以通过代码来获取以上三种类型的实例

  • 实例对象
NSObject *objectInstance1 = [[NSObject alloc] init];
NSObject *objectInstance2 = [[NSObject alloc] init];
  • 实例对象调用class方法，得到类对象
Class objectClass1 = [objectInstance1 class];
Class objectClass2 = [objectInstance2 class];
  • 通过调用运行时方法object_getClass，获取元类对象。
#import <objc/runtime.h>

Class objectMetaClass1 = object_getClass(objectClass1);
Class objectMetaClass2 = object_getClass(objectClass2);

注意，元类对象不能通过类对象调用class方法获得！

我们打印一下他们的内存地址

objectInstance1:0x100544cb0
objectInstance2:0x10053fc70
objectClass1:0x7fffad7cb140
objectClass2:0x7fffad7cb140
objectMetaClass1:0x7fffad7cb0f0
objectMetaClass2:0x7fffad7cb0f0

能够看出，只有两个实例对象的内存地址不同，类和元类内存地址都是相同的。
原因就是他们各自存储的内容和用途不同。

instance、class和meta-class内存结构和用途

首先来看它们各自在内存中存储信息

instance

  • isa指针
  • 其他成员变量

class

  • isa指针
  • superclass指针
  • 成员变量描述信息
  • 属性信息
  • 对象方法信息
  • 协议信息

meta-class

  • isa指针
  • superclass指针
  • 类方法信息

注意：
class和meta-class是同一种类型，内存结构是完全一样的，只是其中存储的信息和用途不同。

接下来看一下isa指针和superclass指针各自的作用

isa指针作用

  • instance 实例对象的isa指针指向类对象
  • class 类对象的isa指针指向元类对象
  • meta-class 元类对象的isa指针指向基类的元类对象

superclass指针作用

  • class 类对象的superclass指针指向父类的类对象。如果没有父类,指向nil
  • meta-class 元类对象的superclass指向父类的元类对象
  • 基类的元类对象的superlcass指针指向基类的class对象

下图是一张经典图，以上结论就是对下图的总结

方法的调用过程

通过上图我们就能知道，当一个方法被调用时，整个的方法调用过程。

定义Person类继承自NSObject，并定义一个类方法和一个实例方法

@interface Person : NSObject
- (void)personInstanceMethod;
+ (void)personClassMethod;
@end
@implementation Person
- (void)personInstanceMethod {
    NSLog(@"personInstanceMethod");
}
+ (void)personClassMethod {
    NSLog(@"personClassMethod");
}
@end

定义Student类继承自Person，同样定义一个类方法和一个实例方法

@interface Student : Person
- (void)studentInstanceMethod;
+ (void)studentClassMethod;
@end
@implementation Student
- (void)studentInstanceMethod {
    NSLog(@"studentInstanceMethod");
}
+ (void)studentClassMethod {
    NSLog(@"studentClassMethod");
}
@end

Person调用实例方法

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

调用过程：
-> 实例对象person通过isa指针找到Person类对象
-> 从Person类对象中保存的实例方法中找到personInstanceMethod方法进行调用

Person调用类方法

[Person personClassMethod];

调用过程：
-> 类对象Person通过isa指针找到Person的元类对象
-> 从Person元类对象中保存的类方法中找到personClassMethod方法进行调用

Student调用父类Person的实例方法

Student *student = [[Student alloc] init];
[student personInstanceMethod];

调用过程：
-> 实例对象student通过isa指针找到Student类对象
-> 发现Student类对象保存的实例方法中，没有personInstanceMethod方法实现
-> 通过Student类对象中superclass找到Person类对象
-> 从Person类对象中保存的实例方法中，找到personInstanceMethod方法进行调用

Student调用父类Person的类方法

[Student personClassMethod];

调用过程：
-> 类对象Student通过isa指针找到Student元类对象
-> 发现Student元类对象中保存的类方法中，没有personClassMethod方法实现
-> 通过Student元类对象中superclass找到Person元类对象
-> 从Person元类对象中保存的类方法中，找到personClassMethod方法进行调用

一个特殊的方法调用

为NSObject实现一个分类，定义一个实例方法test。

@interface NSObject (Test)
@end
@implementation NSObject (Test)
- (void)test {
    NSLog(@"%s --- %@", __func__, self);
}
@end

定义一个Person类继承自NSObject，定义一个类方法test，不给出方法的实现。

@interface Person : NSObject
+ (void)test;
@end
@implementation Person
@end

按照面向对象的经验，Person调用类方法test，会抛出找不到方法实现的异常。

[Person test];

实际运行发现，并没有抛出异常，控制台打印如下。

-[NSObject(Test) test] --- Person

我们来分析一下整个调用过程是怎么样的。

-> Person类对象通过isa指针找到Person元类对象
-> 发现Person元类对象中保存的类方法中，没有test方法实现
-> Person元类对象通过superclass找到基类（NSObject）的元类对象
-> 发现基类的元类对象中保存的类方法中，没有test方法实现
-> 基类的元类对象再通过superclass指针，找到基类的类对象
-> 在基类的类对象中发现test方法的实现，调用test方法

代码验证

下面我们来对上面的描述使用代码的方式进行验证。

OC的类并不提供给我们直接访问isa指针和superclass指针的方法，既然我们已经知道类对象的底层实现，我们就可以自己写一个结构体，通过桥接的方式，将OC的类对象转换成我们自己实现的类对象结构体。

// 自定义类结构体
struct dpl_objc_class {
    Class isa;
    Class superclass;
};

Person *person = [[Person alloc] init];
Student *student = [[Student alloc] init];
        
Class personClass = [person class];
Class personMetaClass = object_getClass(personClass);
Class studentClass = [student class];
Class studentMetaClass = object_getClass(studentClass);
        
// 转换成自定义class的结构体类型
struct dpl_objc_class *myPersonClass = (__bridge struct dpl_objc_class *)(personClass);
struct dpl_objc_class *myPersonMetaClass = (__bridge struct dpl_objc_class *)(personMetaClass);
struct dpl_objc_class *myStudentClass = (__bridge struct dpl_objc_class *)([Student class]);
struct dpl_objc_class *myStudentMetaClass = (__bridge struct dpl_objc_class *)(studentMetaClass);
        
NSLog(@"断点需要 ---");

在断点需要的位置打个断点，在控制台来查看我们需要的信息。

isa指针

(lldb) p/x (long)person->isa
(long) $0 = 0x001d8001000014b1
(lldb) p/x personClass
(dpl_objc_class *) $1 = 0x00000001000014b0
(lldb) p/x personClass->isa
(Class) $2 = 0x001d800100001489
(lldb) p/x personMetaClass
(dpl_objc_class *) $3 = 0x0000000100001488

按照之前所说，实例对象的isa指针指向类对象，类对象的isa指向元类对象，但是通过打印我们发现二者并不相同。
这个原因就在于，在新版runtime源码中，实例对象isa指针的值需要对ISA_MASK做位运算之后才能得到类对象的地址，同理类对象的isa指针也是一样。

ISA_MASK在runtime源码中的定义如下：

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL

因为我们的实例是运行在模拟器上，所以实例对象isa指针需要&上0x00007ffffffffff8才能得到最终的类对象的地址，类对象的isa指针也是同样。

验证结果如下

(lldb) p/x (long)person->isa
(long) $0 = 0x001d8001000014b1
(lldb) p/x personClass
(dpl_objc_class *) $1 = 0x00000001000014b0
(lldb) p/x 0x001d8001000014b1 & 0x00007ffffffffff8
(long) $2 = 0x00000001000014b0
(lldb) p/x personClass->isa
(Class) $3 = 0x001d800100001489
(lldb) p/x personMetaClass
(dpl_objc_class *) $4 = 0x0000000100001488
(lldb) p/x 0x001d800100001489 & 0x00007ffffffffff8
(long) $5 = 0x0000000100001488

superclass指针

(lldb) p/x studentClass->superclass
(Class) $0 = 0x00000001000014b0 Person
(lldb) p/x personClass
(dpl_objc_class *) $1 = 0x00000001000014b0
(lldb) p/x studentMetaClass->superclass
(Class) $2 = 0x0000000100001488
(lldb) p/x personMetaClass
(dpl_objc_class *) $3 = 0x0000000100001488

类对象superclass指针直接指向父类的类对象，类对象的元类对象superclass指针直接指向父类的元类对象。

最终结论

  • 实例对象 isa & ISA_MASK -> 类对象
  • 类对象 isa & ISA_MASK -> 元类对象
  • 类对象的superclass指针直接指向父类对象
  • 元类对象的superclass指针直接指向父类元类对象
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容