IMP:一个函数指针,保存了方法的地址 一张SEL和IMP的对应表 通过SEL可以找到IMP

runtime 运行时

OC是一门动态语言，与C++这种静态语言不同，静态语言的各种数据结构在编译期已经决定了，不能够被修改。而动态语言却可以使我们在程序运行期，动态的修改一个类的结构，如修改方法实现，绑定实例变量等。

NSObject 类 的数据结构。

以前的isa指针就是保存的指针。64位之后还保存了其他的信息 内存管理方面的
@interface NSObject <NSObject> {
    Class isa ;
}

typedef struct objc_class *Class;

--> 唯一的成员变量 objc_class类型的 isa

我们在xcode中看到的数据结构

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;

但是已经在OC 2.0中，这种关于objc_class的定义已经废弃掉了 最新的是下面的

objc_class 结构体 类 objc_class objc_object

runtime 源码
struct objc_class : objc_object {
    // Class ISA;
    Class superclass; 父类
    cache_t cache;             方法缓存
    class_data_bits_t bits;    用于获取类的信息

    class_rw_t *data() {   ///>. 获取到的是 bits里面的信息
        return bits.data();
    }
    void setData(class_rw_t *newData) {
        bits.setData(newData);
    }
    // 省略其他方法
    。。。
}

cache_t cache 方法缓存

1.用于快速查找方法执行函数
2.是可增量扩展的哈希表【提高查找效率】
3.局部性原理的应用[]
struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;
    
    // 省略其余方法
    。。。   
}

typedef uintptr_t cache_key_t;

struct bucket_t {
private:
    cache_key_t _key;
    IMP _imp;

public:
    inline cache_key_t key() const { return _key; }
    inline IMP imp() const { return (IMP)_imp; }
    inline void setKey(cache_key_t newKey) { _key = newKey; }
    inline void setImp(IMP newImp) { _imp = newImp; }

    void set(cache_key_t newKey, IMP newImp);
};

runtime方法调用的流程是，当要调用一个方法时，先不去Class的方法列表中查找，而是先去找cache_t cache 。当系统调用过一个方法后，会将其实现IMP和key存放到cache中，因为理论上一个方法调用过后，被再次调用的概率很大。

class_data_bits_t bits 获取类的基本信息

struct class_data_bits_t {

    // Values are the FAST_ flags above.
    uintptr_t bits;
 
    public:
    class_rw_t* data() {          ///获取类信息的主要数据结构
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
    void setData(class_rw_t *newData) ///> 主要
    {
        assert(!data()  ||  (newData->flags & (RW_REALIZING | RW_FUTURE)));
        // Set during realization or construction only. No locking needed.
        // Use a store-release fence because there may be concurrent
        // readers of data and data's contents.
        uintptr_t newBits = (bits & ~FAST_DATA_MASK) | (uintptr_t)newData;
        atomic_thread_fence(memory_order_release);
        bits = newBits;
    }
--------------------- 

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;

    const class_ro_t *ro;  ///> 只读

    method_array_t methods;    //方法列表
    property_array_t properties; //属性列表
    protocol_array_t protocols;   //协议列表

    Class firstSubclass;
    Class nextSiblingClass;

    char *demangledName;
};

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

    method_list_t *baseMethods() const {
        return baseMethodList;
    }
};

class_rw_t中的方法列表，属性列表，协议列表等包含的是该类本身加上分类的所有的方法，属性，协议，因此是可变的，即可写

它里面包含_class_ro_t中存放的是类初始化时本身的方法，协议，成员变量等，是不包括分类的只读


这是Class的核心，

method_t

struct method_t {
    SEL name;  // 函数名
    const char *types;  // 编码（返回值类型，参数类型）
    IMP imp; // 指向函数的指针（函数地址）
};

types 如何表达返回值和参数的呢？


-(void)aMethod;  参考 Type Encoding
v@：

realizeClass 一个runtime对象方法

objc_class的一个方法 在objc_class的data()方法最初返回的是const class_ro_t * 类型，也就是类的基本信息。因为在调用realizeClass方法前，Category定义的各种方法，属性还没有附加到class上，因此只能够返回类的基本信息。而当我们调用realizeClass时，会在函数内部将Category中定义的各种扩展附加到class上，同时改写data()的返回值为class_rw_t *类

objc_object. 对象

typedef struct objc_object *id;
id = objc_object 

struct objc_object {
private:
    isa_t isa;

public:

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

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

    // 省略其余方法
    ...
}

OC的底层实现是runtime，在runtime这一层，对象被定义为objc_object 结构体，类被定义为了objc_class 结构体。而objc_class 继承于objc_object， 因此，类可以看做是一类特殊的对象

共用体isa_t. 共用体是使用同一段内存空间

 isa 相关操作：
通过。objc_object isa 指针 获取他的类对象。
类对象 的isa指针获取元类对象
类也是一个对象。就叫类对象

弱引用的相关方法：
标记一个对象是否有弱引用

关联对象相关：

内存管理相关：retain release 

isa指针

objc_object 的  isa指针是isa_t类型的指针. isa 共用体
union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;  ///> 表明所属的类
    uintptr_t bits;


#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 33; // MACH_VM_MAX_ADDRESS 0x1000000000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 19;
#       define RC_ONE   (1ULL<<45)
#       define RC_HALF  (1ULL<<18)
    };
};

objc_class 与 objc_object 的关系 元类

objc_class也是一个objc_object类型，这意味着，objc_class中也有一个属性isa，而这个isa，可以表示当前类属于（注意不是继承）哪个类。而这种说明类是属于哪个类的类，我们称之为元类（meta-class）

类保存了对象方法
元类保存了 类方法

类对象 元类对象

类对象存储实力方法列表等信息
元类对象存储类方法等信息

objc_object  通过isa找到他的 类对象 得到实力方法
类继承与  objc_object  他的isa指针指向他的元类对象

元类对象 的isa 指向 根元类对象

跟元类 对象 的superclass 指针指向的是跟类对象

调用类方法。和调用实力方法的区别：
调用的类方法 当我们调用的类方法 找不到的时候 就回调用父类的同名的实力方法

··

iOS源码解析：runtime<一> isa，class底层结构窥探
iOS源码解析：runtime<三>super,isKindOfClass,isMemberOfClass
iOS引用计数管理之揭秘计数存储