[toc]

参考

对象, 类, 元类

objc_class 的结构

基础知识

NSObject

// NSObject 在 NSObject.h 中的定义:
@interface NSObject <NSObject> {
     Class isa; // 相当于 struct objc_class *isa
}

isa

见《isa指针》

id

// id 在 objc.h 中定义:
typedef struct objc_object *id;

id 是 struct objc_object * 的别名, 是指向struct objc_object 变量的指针类型;

id 类型的变量 (如OC对象, 严格来说是指向OC对象的指针) 是指向 struct objc_object 变量的指针, 指向其地址, 即指向OC对象地址

而oc对象就是id类型的变量, 是指向 struct objc_object 变量的指针。

objc_object

// objc_object 在objc.h中定义:
struct objc_object {
    Class isa; // 实例对象的isa指向对应的类
};

Class

typedef struct objc_class *Class; // Class 在objc.h中定义

Class 是 struct objc_class * 的别名, 是指针类型

Class 类型的变量 (如isa、super_class) 是指向 struct objc_class 变量的指针

objc_class

objc_class 是一个结构体类型, 封装了isa、super_class、成员变量列表、实例方法列表(普通类)、类方法列表(元类)、协议列表;

// objc_class 在 <objc/runtime.h> 中定义: (OBJC2_UNAVAILABLE, 已经废弃)
struct objc_class {
    
    Class isa; // 类的isa指针指向其元类(存储静态成员变量和类方法)。
    
    Class super_class; // 父类, 如果该类为根类, 那么super_class == NULL。(在objc4中, 变量名为 superclass ★)
    
    const char *name; // 类名
    
    long version; // 类的版本信息, 默认为0
    
    long info; // 运行期使用的标识位, 比如0x1(CLS_CLASS)表示该类为 普通class，0x2(CLS_META)表示该类为 metaclass。
    
    long instance_size; // 该类的实例变量大小
    
    struct objc_ivar_list *ivars; // 指向成员变量列表的指针
    
    struct objc_method_list **methodLists; // 存放方法列表, 根据info中的标识信息, 若为普通类则存放实例方法; 若为元类则存放类方法。
    
    struct objc_cache *cache; // 因为Objective-C的消息转发需要查找dispatch table甚至可能需要遍历继承体系, 所以缓存最近使用的方法。 系统在调用方法时会先去cache中查找, 查找不到才会去methodLists中遍历获取需要的方法。
    
    struct objc_protocol_list *protocols; // 类需要遵守的协议列表。
};

objc_class 的底层实现, 详见《objc_class 的结构》★

// objc4/objc-runtime-new.h
struct objc_class : objc_object {}

关于2个isa

实例struct objc_object 的 isa 指向 struct objc_class 变量, 即指向 instance 所对应的 Class;

类struct objc_class 的 isa 依然指向 struct objc_class 变量, 但这个变量是元类对象(metaClass object), 即, 类通过其 isa 指针指向其元类。

OC对象, 主要可以分为3种:

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

instance 对象

简介

instance 对象就是类的实例, 是通过类alloc出来的对象，每次调用alloc都会产生新的instance对象

NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];

object1、object2 都是 NSObject 的 instance 对象(实例对象)
它们是不同的两个对象，分别占据着两块不同的内存

本质

每个OC对象都是一个结构体指针, 指向 objc_object 类型的结构体, 该结构体包含了一个 isa 指针;

isa 指向 objc_class 类型的结构体, 亦即该对象对应的类;

任何 OC 对象本质上都是其类的实例;

任何对象都有isa指针, 对象通过其 isa 指针指向其类;

instance 对象在内存中存储的信息包括:

1. isa指针
2. 其他成员变量 (具体值 ivar value)

为啥都有isa指针?

因为每个instance最终都是继承自NSObject, 所以每个instance的内存中都包含有NSObject的内容

class 对象

简介

类对象是由编译器创建的, 即在编译时所谓的类, 就是指类对象; (官方文档: The class object is the compiled version of the class)

一个类永远只有一个类对象。

任何直接或间接继承了 NSObject 的类, 它的实例对象中都有一个isa指针, 指向它的类对象。

这个类对象中存储了关于这个实例对象所属的类的定义的一切: 包括变量, 方法, 遵守的协议等等。

因此, 类对象能访问所有关于这个类的信息, 利用这些信息可以产生一个新的实例, 但是类对象不能访问任何实例对象的内容。

当你调用一个 “类方法” 例如 [NSObject alloc], 你事实上是发送了一个消息给他的类对象。

总之, 类对象是一个功能完整的对象, 所以也能被动态识别(dynamically typed), 接收消息, 从其他类继承方法。

<u>特殊之处在于它们是由编译器创建的, 缺少它们自己的数据结构(实例变量), 只是在运行时产生实例的代理。</u>

#import <objc/runtime.h>

NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];

Class objectClass1 = [object1 class];
Class objectClass2 = [[object2 class] class]; // class 返回的一直是class对象, 而不是元类对象, 不管调用多少次
Class objectClass3 = object_getClass(object1); // Runtime API
Class objectClass4 = object_getClass(object2);
Class objectClass5 = [NSObject class];

objectClass1 ~ objectClass5 都是 NSObject 的class对象（类对象）
它们是同一个对象。每个类在内存中有且只有一个class对象。

class 对象在内存中存储的信息主要包括:

1. isa指针
2. superclass指针
3. 类的属性信息（@property）
4. 类的对象方法信息（instance method）
5. 类的协议信息（protocol）
6. 类的成员变量信息（ivar）(ivar type and name etc.info)
7. ...

本质

类本质上是一个对象, 类是元类的实例。

OC中任何的类定义都是对象, 即在程序启动时, 任何类定义都对应于一块内存。

编译时, 编译器会给每一个类生成且只生成一个 "描述其定义的对象" , 也就是苹果说的类对象(class object), 他是一个单例(singleton)

所有实例对象都是在运行时由OC的运行时库生成的, 类对象就是运行时库用来创建实例对象的依据。

meta-class 对象

简介

元类对象即是描述类对象的类, 每个类都有自己的元类, 也就是类的结构体 objc_class 中 isa 指向的类。

元类也是类, 它也是对象。

每个类在内存中有且只有一个元类对象;

meta-class 对象和 class 对象, 都是 Class 类型, 他们的内存结构是一样的 (即struct objc_class)，但是用途不一样;

元类定义了类方法的列表。

OC的类方法是使用元类的根本原因, 因为其中存储着对应的类对象调用的方法, 即类方法。

// 将类对象入参, 获得元类对象
// objectMetaClass 是 NSObject 的 meta-class 对象
Class objectMetaClass = object_getClass([NSObject class]);

元类对象在内存中存储的信息主要包括:

1. isa指针
2. superclass指针
3. 类的类方法信息（class method）
4. ...

本质

实际上, 类对象是元类对象的一个实例！元类描述了类对象, 就像类对象描述了普通对象一样。

不同的是, 元类的方法列表是类方法的集合, 由类对象的选择器来响应。

向一个类发送消息时, objc_msgSend 会通过类对象的isa指针定位到元类, 并检查元类的方法列表(包括父元类), 来决定调用哪个方法。

元类代替了类对象描述了类方法, 就像类对象代替了实例对象描述了实例化方法。

很显然, 元类也是对象, 也应该是其他类的实例, 实际上元类是根元类的实例, 而根元类是其自身的实例, 即根元类的isa指针指向自身。

类的 super_class 指向其父类, 而元类的 super_class 则指向父类的元类。

元类的 super_class 链与类的 super_class 链平行, 所以类方法的继承与实例方法的继承也是并行的。

而根元类的 super_class 指向根类, 这样, 整个指针链就链接起来了!

给任何一个对象发送消息, 方法的检查从对象的 isa 指针开始, 然后是父类。

实例方法在类中定义, 类方法在元类和根类中定义。在一些计算机语言的原理中, 一个类和元类层次结构可以更自由的组成, 更深元类链和从单一的元类继承的更多的实例化的类。OC 的类方法是使用元类的根本原因, 在其他方面试图在隐藏元类。

例如, [NSObject class] 完全相等于 [NSObject self], 所以, 在形式上他还是返回的 NSObject->isa 指向的元类。

NSLog(@"%@ %@", [NSObject self], [NSObject class]); // 输出 NSObject NSObject

综上所述, 类对象中包含了类的实例变量、实例方法的定义, 而元类对象中包括了类的类方法的定义。

类对象和元类对象中当然还会包含一些其它的东西, 苹果以后也可能添加其它的内容, 但对于我们只需要记住:

• 类对象存的是关于实例对象的信息(变量、实例方法等);
• 元类对象中存储的是关于类的信息(类的版本、名字、类方法等)。

要注意的是, 类对象和元类对象的定义都是 objc_class 结构, 其不同仅仅是在用途上, 比如, 其中的方法列表在类对象中保存的是实例方法, 而在元类对象中则保存的是类方法。

实例对象、类和元类的关系图:

image

image

关于 isa

1. instance 的 isa 指向 class
2. class 的 isa 指向其元类;
3. 根类的 isa 指向根元类(基类的元类);
4. (所有)元类的 isa 指向根元类;
5. 根元类的 isa 指向根元类自身;

关于 superClass

1. 根类的 superClass 指向nil (没有父类);
2. 非根元类的 superClass 指向其父元类(父类的元类), 最终继承于根元类;
3. 根元类的 superClass 指向根类 (有父类, 因为根元类是通过继承根类产生的);

方法调用过程(轨迹)

见<方法缓存>

相关方法

获取类的方法

<objc/runtime.h> 的源码都在 objc4 里面

objc_getClass

#import <objc/runtime.h>
Class _Nullable objc_getClass(const char *_Nonnull name)

参数: 字符串类名

返回: 对应的类对象

object_getClass

#import <objc/runtime.h>
// 获取类 / 元类对象
Class _Nullable object_getClass(id _Nullable obj)

跟随实例的isa指针, 返回此实例所属的类;

参数和返回: 根据传入对象不同, 返回不同对象

• instance对象 -> class对象
• class对象 -> meta-class对象
• meta-class对象 -> 基类(NSObject)的meta-calss对象

class

// objc4/NSObject.mm
+ (Class)class {
    return self;
}

- (Class)class {
    return object_getClass(self);
}

返回的就是类对象, 不管调用多少次;

• 对于实例对象, 会返回类;
• 对于类, 则不会返回元类, 而只会返回类本身。

superclass

+ (Class)superclass {
    // objc_class 有个成员 Class superclass;
    return self->superclass;
}

- (Class)superclass {
    // class_getSuperclass(object_getClass(self));
    return [self class]->superclass;
}

其他方法

class_isMetaClass

判断某类是否为元类。

// 查看Class是否为meta-class
BOOL class_isMetaClass(Class _Nullable cls);

创建新类并添加方法和实例变量

Class objc_allocateClassPair(Class superclass, const char *name, size_t extraBytes);

BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types);

BOOL class_addIvar(Class cls, const char *name, size_t size, uint8_t alignment, const char *types);

void objc_registerClassPair(Class cls);