instance/class/metaclass類裏存了什麼？

概述

上一篇文章咱們學習過對象本質以後，咱們知道對象內部有一個isa指針，本文將描述對象的分類，學習完以後，須要咱們回答如下幾個問題：

1. OC中有幾種對象，它們分別是什麼？
2. 對象的isa指針指向哪裏？
3. OC的類信息存放在哪裏？
4. 對象方法的調用流程。

OC對象的分類

OC中有三種對象，咱們將依次討論，它們分別是：

• instance 實例對象
• class 類對象
• metaclass 元類對象

instance

instance 是實例對象，經過alloc 出來的對象，每次調用alloc都會產生新的instance對象。

NSObject *obj1 = [[NSObject alloc] init];
NSObject *obj2 = [[NSObject alloc] init];
// obj一、obj2都是instance對象
複製代碼

obj一、obj2是NSObject的instance對象，它們是不一樣的兩個對象，分別佔據着兩塊不一樣的內存空間。

instance 對象在內存中存儲的信息有：

• isa指針，isa繼承自NSObject，isa始終會排在最前面。
• 其餘成員變量

class

class是類對象，在內部中存儲的信息包括：

• isa指針
• superClass指針
• 類的屬性信息（@property）
• 類的對象方法信息（instance method）
• 類的協議信息（protocol）
• 類的成員變量信息（ivar， 描述信息）
• ...

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

Class objectClass1 = [object1 class];
Class objectClass2 = object_getClass(object1);
Class objectClass3 = [NSObject class];
Class objectClass4 = objc_getClass("NSObject");

Class objectClass5 = [object2 class];
Class objectClass6 = object_getClass(object2);

NSLog(@"%p-%p-%p-%p-%p-%p", objectClass1, objectClass2, 
      objectClass3, objectClass4, objectClass5, objectClass6); 
//0x7fff9da14118-0x7fff9da14118-0x7fff9da14118-0x7fff9da14118-0x7fff9da14118-0x7fff9da14118
複製代碼

經過 [object1 class] 或者 NSObject class] 或者 object_getClass(object1) 三個方法獲取class對象。

meta-class

//獲取元類
Class objectMetaClass = object_getClass([NSObject class]);
複製代碼

meta-class對象內部中存儲的信息包括：

• isa
• superclass
• 類方法信息（class method）
• ...

class與meta-class的內存結構是同樣的，都是Class（struct objc_class結構體）

instance、class、meta-class結構

注意：

Class objectClass = [[NSObject class] class]; //返回的class對象，不管調用多少次class方法，返回的都是class對象。

object_getClass(obj1); //若是參數是instance對象，則返回class對象
//若是參數是class對象，則返回meta-class對象
//若是是meta-class對象，返回NSObject（基類）的meta-class對象
object_getClass([NSObject class]); 

//查看Class是不是meta-class
BOOL isMetaClass = class_isMetaClass([NSObject class]);

//返回參數對應的class對象。
Class class = objc_getClass("NSObject");
複製代碼

isa指針和superclass指針

瞭解了instance、class、metaclass的結構以後，咱們看一下，isa指針和superclass指針。instance、class、metaclass內部都含有isa指針，而只有class、metaclass內部含有suerclass指針。

isa指針

• instance的isa指向class。
• class的isa指向metaclass。
• metaclass的isa指向基類的metaclass。

super指針

• class的superclass指向父類的class。
• 基類的superclass指向nil。
• metaclass的superclass指向父類的metaclass。
• 基類的metaclass的superclass指向基類的class。

下面咱們建立兩個類Person 與 Student 其中，Student繼承自Person。

Person類

@interface Person : NSObject<NSCopying> {
    @public
    int _age;
}
@end
@implementation Person
- (void)personInstanceMethod {
}
+ (void)personClassMethod {
}
- (nonnull id)copyWithZone:(nullable NSZone *)zone {
    return nil;
}
@end
複製代碼

Student類

@interface Student : Person<NSCoding>
@end

@implementation Student
- (void)studentInstanceMethod {    
}
+ (void)studentClassMethod {    
}
- (nullable instancetype)initWithCoder:(nonnull NSCoder *)coder {
    return nil;
}
- (void)encodeWithCoder:(nonnull NSCoder *)coder {
}
- (nonnull id)copyWithZone:(nullable NSZone *)zone {
    return nil;
}
@end
複製代碼

而後咱們分析以下調用：

Student *student = [[Student alloc] init];
// 實例（instance）對象，調用類（class）方法。

// 先經過實例對象student的isa指針找到Student類對象
// 再在Student類對象內部找到studentInstanceMethod方法，並觸發調用
[student studentInstanceMethod];// -> objc_msgSend(student, studentClassMethod);

// 先經過實例對象student的isa指針找到Student類對象
// 再在Student類對象內部查找personInstanceMethod，沒有找到。
// 經過Student類對象的superclass指針查找到Person類對象，在其內部找到personInstanceMethod方法，並觸發調用
[student personInstanceMethod];// -> objc_msgSend(student, personInstanceMethod);

// 類（class）對象調用類方法。

//在Student類對象內部查找studentClassMethod方法，找到並觸發調用
[Student studentClassMethod]; // -> objc_msgSend([Student class], studentClassMethod);

//在Student類對象內部查找personClassMethod方法，沒有找到
//經過Student類對象的superclass指針，找到Person類對象，
//在其內部找到personClassMethod，並觸發調用。
[Student personClassMethod]; // -> objc_msgSend([Student class], personClassMethod);
複製代碼

經過分析，咱們得出以下結論：

• instance調用對象方法的軌跡，經過instance的isa找到class對象，在class對象內部查找方法，找不到就經過superclass指針找到其父類，而後繼續查找方法。
• class調用類方法的軌跡，經過class的isa找到metaclass，在metaclass內部查找方法，找不到就經過superclass指針到到其父類，而後繼續查找方法。

經過上面的分析，咱們畫出以下isa與superclass的指向圖，以下：

在上圖中，有一條特殊的線，基類的metaclass的superclass指針指向的不是nil，而是基類的class對象。咱們證明一下。

咱們給NSObject對象增長一個分類，在分類中增長一個實例方法，以下：

@interface NSObject (test)
- (void)test;
@end

@implementation NSObject (test)
- (void)test{
    NSLog(@"-NSObject (test)");
}
@end
複製代碼

經過上面的學習，咱們知道-test 是在NSObject的class對象內部實現的。

而後咱們實現Person類，Person類只是基礎NSObject。

//
//   main.m
//   Class對象
//
//   Created  by MrLi on 2020/5/16
//   Modified by MrLi
//   Copyright © 2020 MrLi. All rights reserved.
//
   

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "NSObject+test.h"

@interface Person : NSObject<NSCopying>
@end

@implementation Person
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        [Person test];
    }
    return 0;
}
複製代碼

咱們在main方法直接調用[Person test]。它的調用軌跡是：

1. 經過Person類對象的isa找到Person的metaclass對象，在其內部查找test方法，沒找到。
2. 而後經過Person metaclass的superclass指針找到其父類NSObject metaclass，在其內部找到test方法，依然找不到。
3. 這是若是NSObject的metaclass的superclass指向爲nil，test的調用應該報錯。但卻調用到了NSObject的class對象內部的-test方法。可見基類的metaclass的superclass指向基礎的class對象。

如何經過isa找到class或者metaclass

理論上，instance的isa指針指向的內容應該是class的地址，class的isa指針指向的內容應該是metaclass的地址。但其實它是經過& ISA_MASK 計算出來的。

在不一樣的架構下 ISA_MASK 取值不一樣。以下

# if __arm64__
# define ISA_MASK 0x0000000ffffffff8ULL
# elif __x86_64__
# define ISA_MASK 0x00007ffffffffff8ULL
複製代碼

咱們看以下代碼：

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

@interface Student : Person<NSCoding>
@end
@implementation Student
@end

struct myclass {
    Class isa;
    Class superclass;
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Student *stu = [[Student alloc] init];
       struct myclass *stuclass = (__bridge struct myclass*)([Student class]);
        struct myclass *stumetaClass = (__bridge struct myclass*)object_getClass([Student class]);
        NSLog(@"%p-%p-%p", stu, stuclass, stumetaClass);
        NSLog(@"查看內存"); //斷點
    }
    return 0;
}
複製代碼

2020-05-17 17:02:06.481250+0800 Class對象[2250:1165673] 0x1031ab810-0x1000023e8-0x1000023c0

(lldb) p/x stu->isa

(Class) $0 = 0x001d8001000023e9 Student

(lldb) p/x 0x001d8001000023e9 & 0x00007ffffffffff8

(long) $1 = 0x00000001000023e8

(lldb) p/x stuclass->isa

(Class) $2 = 0x00000001000023c0

(lldb) p/x 0x00000001000023c0 & 0x00007ffffffffff8

(long) $3 = 0x00000001000023c0

(lldb) p/x stuclass->superclass

(Class) $4 = 0x0000000100002398 Person

(lldb) p/x [Person class]

(Class) $6 = 0x0000000100002398 Person

經過分析日誌，咱們得出結論：

• instance的isa & ISA_MASK 獲取到對應的class地址。
• class的isa & ISA_MASK 獲取到對應的metaclass的地址。
• class、metaclass的superclass地址就是其父類地址。

class、metaclass內部結構

// objc4-781 
struct objc_object {
    Class _Nonnull isa;
};

struct objc_class : objc_object {
    Class superclass;
    cache_t cache;
    class_data_bits_t bits;    // 用戶獲取類的具體信息
}

struct class_rw_t {
    uint32_t flags;
    uint16_t witness;
    explicit_atomic<uintptr_t> ro_or_rw_ext;
    Class firstSubclass;
    Class nextSiblingClass;

public:  
  // 獲取ro
    const class_ro_t *ro() const {
        auto v = get_ro_or_rwe();
        if (slowpath(v.is<class_rw_ext_t *>())) {
            return v.get<class_rw_ext_t *>()->ro;
        }
        return v.get<const class_ro_t *>();
    }

    void set_ro(const class_ro_t *ro) {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            v.get<class_rw_ext_t *>()->ro = ro;
        } else {
            set_ro_or_rwe(ro);
        }
    }
  // 獲取methods
    const method_array_t methods() const {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            return v.get<class_rw_ext_t *>()->methods;
        } else {
            return method_array_t{v.get<const class_ro_t *>()->baseMethods()};
        }
    }
	//獲取 properties
    const property_array_t properties() const {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            return v.get<class_rw_ext_t *>()->properties;
        } else {
            return property_array_t{v.get<const class_ro_t *>()->baseProperties};
        }
    }
	//獲取 protocols
    const protocol_array_t protocols() const {
        auto v = get_ro_or_rwe();
        if (v.is<class_rw_ext_t *>()) {
            return v.get<class_rw_ext_t *>()->protocols;
        } else {
            return protocol_array_t{v.get<const class_ro_t *>()->baseProtocols};
        }
    }
};

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize; // 
#ifdef __LP64__
    uint32_t reserved;
#endif

    const uint8_t * ivarLayout;
    
    const char * name; // 類名
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars; //成員變量列表

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;
};
複製代碼

總結

至此，本文到此結束，還記得開篇的4個問題嗎？想必你已經有了答案！

技術交流