iOS底层原理：类&类的结构分析

在分析类的结构之前，我们需要先搞清楚类的内存分布情况。

类的内存分布

首先创建一个Person类：

// Person 类
@interface Person : NSObject

- (void)sayHello;
+ (void)sayHi;

@end

@implementation Person

- (void)sayHello {
    NSLog(@"Say Hello");
}

+ (void)sayHi {
    NSLog(@"Say Hi");
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        Person *person = [[Person alloc] init];
        
        NSLog(@"%@",person);
    }
    return 0;
}

类的lldb调试分析

通过上图中可以看出 0x00000001000012e8 和 0x00000001000012c0 为什么打印出的结果都是 Person 呢？这个东西其实就是元类。

那么什么是元类呢？

元类

每一个对象都对应一个类。Person 类就是 person 对象的类，换句话说就是 person 对象的isa指针指向 Person 对应的结构体；[Person class] 也是对象，描述它的类就是元类，换句话说[Person class] 对象的isa指向的就是元类

元类的定义和创建都是由编译器自动完成。

元类保存了类方法的列表。当一个类方法被调用时，元类会首先查找它本身是否有该类的方法的实现，如果没有则该类会向它的父类查找该方法，知道一直找到继承链的头。

元类分析 元类跟踪

从上图中我们可以看到，我们通过isa可以一直找到NSObject类。通过 person对象的isa指针可以找到Person类，通过Person的isa指针可以找到元类Person，而通过元类Person的isa指针又可以找元类Person的元类NSObject，通过元类NSObject的isa指针找到的还是NSObject，其实这个时候的NSObject叫做根元类

但是NSObject的类和 NSObject.class 的指针地址不一样呢？是NSObject类会在内存中存在多份吗？

我们通过如下代码打印来看下：

void getClassInfo() {
    Class class1 = [Person class];
    Class class2 = [Person alloc].class;
    Class class3 = object_getClass([Person alloc]);
    
    NSLog(@"\n%p\n%p\n%p\n",class1,class2,class3);
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        getClassInfo();
    }
    return 0;
}

输出结果如下：

2020-09-15 20:49:21.406345+0800 ObjectAnalysis[34085:811450] 
0x1000012f0
0x1000012f0
0x1000012f0
Program ended with exit code: 0

可以看出其实类对象在整个内存中只有一份。

因此我们可以得出一个著名的isa的走位图。

isa的走位图&继承图

走位图

isa查找流程

• 示例对象的isa指针类对象
• 类对象的isa指向元类对象
• 元类对象的isa指向根元类
• 根元类的isa指向它自己本身，从而形成了闭环

继承关系

类对象的继承关系

• 类继承于它的父类
• 父类继承它的父类
  ...
• 直到找到根类，也就是NSObject
• NSObject 则继承于nil，这也就是所有的根源，即无中生有

元类的继承关系

• 子类的元类继承与 父类的元类
• 父类的元类继承它的父类的元类
  ...
• 直到找到根元类
• 而根元类则是继承于NSObject

tips:实例对象是没有继承关系的，只有类才有继承关系

对象的本质

对象的本质其实就是结构体，而编译到底层都是继承自objc_class的结构体

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    class_rw_t *data() const {
        return bits.data();
    }

    // 代码过多，自动省略
    ...
};

// objc_object
struct objc_object {
private:
    isa_t isa;

public:

    // ISA() assumes this is NOT a tagged pointer object
    Class ISA();

    // rawISA() assumes this is NOT a tagged pointer object or a non pointer ISA
    Class rawISA();

    // getIsa() allows this to be a tagged pointer object
    Class getIsa();

    // 代码过多，自动省略
    ...
};

通过源码可以看出 objc_class 其实就是继承自 objc_object。

所以我们可以看出所有的 对象、类和元类都有isa指针，是因为都继承自 objc_object，而 objc_object中有个私有变量isa。

objc_object、objc_class、isa、object、NSObject的关系如下图所示：

关系图

我们接下来重点就是分析类的结构了

类的结构分析

再开始前，先分析下objc_class的结构图

objc_class

• isa 是指向元类的指针
• superclass 是指向当前类的父类
• cache 是用于缓存方法的，用于加速方法的调用
• bits 是存储类的方法、属性、协议等信息的地方

一般我们获取到bits，然后才能获取到我们需要的信息，那么我们就需要进行32位指针的偏移，为什么是32位指针的偏移，请看下面的代码段分析：

struct objc_class : objc_object {
    // Class ISA;  // 指针占 8 字节
    Class superclass; // 指针占 8 字节
    cache_t cache;   // 占 16 字节，具体分析，看cache_t 结构体的分析
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    class_rw_t *data() const {
        return bits.data();
    }

    // 代码过多，自动省略
    ...
};

// mask_t 的定义
#if __LP64__
typedef uint32_t mask_t;  // x86_64 & arm64 asm are less efficient with 16-bits
#else
typedef uint16_t mask_t;
#endif

// 结构体指针字节大小，看里面的成员变量，而大部分都是 static 和方法都不存在结构体里面
struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
    explicit_atomic<struct bucket_t *> _buckets;  // 结构体指针 8 字节
    explicit_atomic<mask_t> _mask;  // uint32_t 占 4 字节
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;
#if __LP64__
    uint16_t _flags; // 占 2 字节
#endif
    uint16_t _occupied; // 占 2 字节

    // 方法代码过多，自动省略
    ...
};

class_data_bits_t

在objc_class结构体中的注释中已经写到class_data_bits_t相当于class_rw_t指针加上rr/alloc的标志。

class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

而在class_data_bits_t结构体中为我们提供了一个用于返回其中的class_rw_t *的方法

struct class_data_bits_t {
    friend objc_class;

    // Values are the FAST_ flags above.
    uintptr_t bits;

     // 代码过多，自动省略
    ...
public:

    class_rw_t* data() const {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
    // 代码过多，自动省略
    ...
};

class_rw_t

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint16_t witness;
#if SUPPORT_INDEXED_ISA
    uint16_t index;
#endif

    explicit_atomic<uintptr_t> ro_or_rw_ext;

    Class firstSubclass;
    Class nextSiblingClass;

    // 省略过多的代码  
    ...

    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()};
        }
    }

    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};
        }
    }

    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};
        }
    }
};

可以看出，我们可以通过class_rw_t结构体中提供的methods()、properties()、protocols()获取到对应的方法、属性和协议。

那么接下来我们通过lldb调试来查找对应的class_data_bist_t bits，查看相应的信息。

class_rw_t

当我们获取到class_rw_t结构体信息后，接下来想要获取到方法、属性或者协议，就需要通过调用其提供的方法来进行获取。

属性列表 properties()

属性信息

• 1、通过properties()可以获取到对应的属性列表
• 2、通过get方法访问第一个属性，可以发现是我们定义的name属性

【error】但是尝试去获取第二个属性的时候，发现数组越界了，这是为什么呢？我们不是还定义了一个hobby吗？

由此引出成员变量、实例变量和属性的区别

成员变量/实例变量/属性

成员变量： Member Variable declarations
类： Class (description/template for an object)
实例： Instance (manifestation of a class)
消息： Message (sent to object to make it act)
方法： Method (code invoked by a Message)
实例变量： Instance Variable (object-specific storage)
超类/子类： Superclass/Subclass (Inheritance)
协议：  Protocol (non-class-specific methods)

从上面的解释，可以看出，实例是针对类而言的，。实例是指类的声明，由此推理，实例变量是指由类声明的对象。

而属性和成员变量的区别在于有无setter、getter方法。

方法列表 methods()

我们还是先通过lldb调试来查找方法列表。

methods

通过上图的lldb调试过程，我们可以发现：

• method_list_t中有方法的总个数 count=4
• 会优先存储我们定义的实例方法
• 会有一个隐藏的析构函数 .cxx_destruct，实现ARC下自动释放内存的工作
• setter、getter方法的存储

其实探索到这里，发现我们还遗留了两个问题：
1、成员变量的存储
2、类方法的存储

成员变量的存储

其实通过objc_class的源码，我们可以知道里面其实还有个ro方法，会返回一个class_ro_t的结构体的信息。打印信息如下：

ivars

在class_ro_t结构体中其实有很多的成员变量和方法，其实class_rw_t中的ro，在类的编译期就已经确定了属性、方法以及要遵循的协议，objc_class中的bits中的data部分存放了ro信息。而在runtime运行之后，准确的说是在运行runtime的realizeClass方法时，会生成class_rw_t结构体，该结构体包含了class_ro_t，并且更新了data部分。换成了class_rw_t结构体的地址。

由上图的llbd打印出的ivars信息中，可以看到，我们生命的属性，也会在ivars中生成一个 _name的成员变量。这也就是我们为什么可以通过 _name和self.name来访问属性的原因了。

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;

    // This field exists only when RO_HAS_SWIFT_INITIALIZER is set.
    _objc_swiftMetadataInitializer __ptrauth_objc_method_list_imp _swiftMetadataInitializer_NEVER_USE[0];

    _objc_swiftMetadataInitializer swiftMetadataInitializer() const {
        if (flags & RO_HAS_SWIFT_INITIALIZER) {
            return _swiftMetadataInitializer_NEVER_USE[0];
        } else {
            return nil;
        }
    }

    method_list_t *baseMethods() const {
        return baseMethodList;
    }

    class_ro_t *duplicate() const {
        if (flags & RO_HAS_SWIFT_INITIALIZER) {
            size_t size = sizeof(*this) + sizeof(_swiftMetadataInitializer_NEVER_USE[0]);
            class_ro_t *ro = (class_ro_t *)memdup(this, size);
            ro->_swiftMetadataInitializer_NEVER_USE[0] = this->_swiftMetadataInitializer_NEVER_USE[0];
            return ro;
        } else {
            size_t size = sizeof(*this);
            class_ro_t *ro = (class_ro_t *)memdup(this, size);
            return ro;
        }
    }
};

类方法的存储

其实我们从上面的isa走位图中就可以知道一点，所有的实例对象的isa都是指向其元类的，那么我们是否可以查看其元类中的方法列表。下面我们通过lldb调试来看一下。

类方法

所以可以看出对象中的类方法都是存储在其元类中的。