isa 走位图

在讲 OC->Class 底层类结构之前，先看下下面这张图：

经过isa走位图得出的结论是： 1，类，父类，元类都包括了 isa, superclass
2，目标isa指向类目标，类目标的isa指向了元类，元类的 isa 指向了根元类，根元类 isa 指向自己
3，类的 superclass 指向父类，父类的 superclass 指向的根类，根类的superclass 指向的nil
4，元类的 superclass 指向父元类，父元类 superclass 指向的根元类，根元类 superclass 指向根类，根类 superclass 指向nil

这下又复习了 isa ，superclass 走位；那么问题这些类，类目标，元类目标当中的在底层展现的数据结构是怎样呢，这是我需求探究的，于是把源码贴出来展开分析下：

struct 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 *data() const {
        return bits.data();
    }
    const class_ro_t *safe_ro() const {
        return bits.safe_ro();
    }
}

从源码没见 isa 特点，其实它承继了objc_object ，而 objc_object 中有个isa ，在运行时类图生成中会发生一个isa 指向objc_object 这个类图，而 superclass 指向它的父类；依据上面 isa , superclass 走位图就知道它的指向联系。

cache_t & class_data_bits_t

cache 办法缓存，这个效果将常调用的办法缓存下来；便于下次直接查找调用，进步查找功率。它的结构：

struct cache_t {
	struct bucket_t *buckets() const;//存储办法的散列表
	mask_t mask() const;//散列表缓存长度
	mask_t occupied() const;//已缓存办法个数
}

struct class_data_bits_t {
    class_rw_t* data() const;//类信息
}

bits 存储详细类信息，它需求&FAST_DATA_MASK来核算得到类心一切信息，源码如下：

FAST_DATA_MASK 掩码值

bool has_rw_pointer() const {
	#if FAST_IS_RW_POINTER
	        return (bool)(bits & FAST_IS_RW_POINTER);
	#else
	        class_rw_t *maybe_rw = (class_rw_t *)(bits & FAST_DATA_MASK);
	        return maybe_rw && (bool)(maybe_rw->flags & RW_REALIZED);
	#endif
}

经过源码的确需求这种办法核算能得到类的存储信息；那为什么要用这种办法去处理呢。比方说我要得到存储在 class_rw_t 类信息信息我只需经过 FAST_DATA_MASK 掩码值就能得到它的地址信息，经过地址信息就能从内存中拿到一切类的存储信息。

那这样我的FAST_DATA_MASK掩码值不一样，我经过&核算，得到的数据信息也就不一样，不得不说苹果工程师想的周到，而且这种办法不只isa也是这样，许多当地都用这种办法取值，大大进步访问速度，数据提取功率。

class_rw_t ，class_ro_t，class_rw_ext_t

struct class_rw_t {
     const class_ro_t *ro() const ;
     const method_array_t methods() const ;//假如是类目标：放目标办法，元类：元类目标办法
     const property_array_t properties() const;
     const protocol_array_t protocols() const;
     class_rw_ext_t *ext() const;
}
struct class_rw_ext_t {
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;
    uint32_t version;
}

能够看出类的信息详细就存储在class_rw_t，class_ro_t，class_rw_ext_t 中，

剖析下class_rw_t 先看看method_array_t，property_array_t，protocol_array_t源码结构

class property_array_t :
    public list_array_tt<property_t, property_list_t, RawPtr>
{
    typedef list_array_tt<property_t, property_list_t, RawPtr> Super;
 public:
    property_array_t() : Super() { }
    property_array_t(property_list_t *l) : Super(l) { }
};
class protocol_array_t : 
    public list_array_tt<protocol_ref_t, protocol_list_t, RawPtr>
{
    typedef list_array_tt<protocol_ref_t, protocol_list_t, RawPtr> Super;
 public:
    protocol_array_t() : Super() { }
    protocol_array_t(protocol_list_t *l) : Super(l) { }
};

看完之后，他们都承继list_array_tt，那么 list_array_tt 是什么鬼，它数据结构是怎样的，这下在取找下它。源码如下：

template <typename Element, typename List, template<typename> class Ptr>
class list_array_tt {
 protected:
    template <bool authenticated>
    class iteratorImpl {
        const Ptr<List> *lists;
        const Ptr<List> *listsEnd;
    }
    using iterator = iteratorImpl<false>;
    using signedIterator = iteratorImpl<true>;
 public:
    list_array_tt() : list(nullptr) { }
    list_array_tt(List *l) : list(l) { }
    list_array_tt(const list_array_tt &other) {
        *this = other;
    }
    void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return;
        if (hasArray()) {
            // many lists -> many lists
            uint32_t oldCount = array()->count;
            uint32_t newCount = oldCount + addedCount;
            array_t *newArray =(array_t*)malloc(array_t::byteSize(newCount));
            newArray->count = newCount;
            array()->count = newCount;
            for (int i = oldCount - 1; i >= 0; i--)
                newArray->lists[i + addedCount] = array()->lists[i];
            for (unsigned i = 0; i < addedCount; i++)
                newArray->lists[i] = addedLists[i];
            free(array());
            setArray(newArray);
            validate();
        }
        else if (!list  &&  addedCount == 1) {
            // 0 lists -> 1 list
            list = addedLists[0];
            validate();
        } 
        else {
            // 1 list -> many lists
            Ptr<List> oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount;
            setArray((array_t *)malloc(array_t::byteSize(newCount)));
            array()->count = newCount;
            if (oldList) array()->lists[addedCount] = oldList;
            for (unsigned i = 0; i < addedCount; i++)
                array()->lists[i] = addedLists[i];
            validate();
        }
    }
}

我把主要当地拿去出来，能够看到 attachLists 它的意图是将一个或多个列表（List类型）附加到某个list_array_tt目标中。这个目标能够包括零个、一个或多个列表，这些列表能够是单个指针，也能够是指针数组。函数的输入参数是一个指向List指针数组的指针addedLists和一个无符号整数addedCount，表示要添加的列表数量。

由此我推断它是一个数组，而且是一个二维数组存储的，一切由此得出 class_rw_t 中methods，properties，protocols这几个特点利用二维数组取存储类的办法，协议等信息，而且是可读可写的特点。

那它规划这种二维数组有什么优点呢？当然有优点，它能够动态的给数组里面添加删去办法，很便利咱们分类办法的编写完进行存储。

那搞清楚了 class_rw_t 几个重要数据存储信息，那 class_rw_t 它的效果是干什么的呢；

从class_rw_t 结构体界说来看；它是在运用运行时，将OC类，分类的信息直接写入到class_rw_t结构的数据结构中，在类的办法，协议进行调用时，从里面去读取，然后常调用的办法，又存储在cache_t这个结构体中，可想而知，苹果对OC类的处理，煞费苦心。

struct class_ro_t

在 class_rw_t结构体中有个 class_ro_t 结构体，在探究下这个东西做什么的，它的源码如下：

struct class_ro_t {
    WrappedPtr<method_list_t, method_list_t::Ptrauth> baseMethods;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;
    property_list_t *baseProperties;
}

先说说 ivars 这个特点修饰的结构体源码如下：

struct ivar_list_t : entsize_list_tt<ivar_t, ivar_list_t, 0> {
    bool containsIvar(Ivar ivar) const {
        return (ivar >= (Ivar)&*begin()  &&  ivar < (Ivar)&*end());
    }
};

这个形似只有一个承继 entsize_list_tt,那在探究下源码：

struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
     struct iteratorImpl {
     uint32_t entsize;
        uint32_t index;  // keeping track of this saves a divide in operator-
        using ElementPtr = std::conditional_t<authenticated, Element * __ptrauth(ptrauth_key_process_dependent_data, 1, 0xdead), Element *>;
        ElementPtr element;
        typedef std::random_access_iterator_tag iterator_category;
        typedef Element value_type;
        typedef ptrdiff_t difference_type;
        typedef Element* pointer;
        typedef Element& reference;
        iteratorImpl() { }
        iteratorImpl(const List& list, uint32_t start = 0)
            : entsize(list.entsize())
            , index(start)
            , element(&list.getOrEnd(start))
        { }
     }
}

能够看出这段代码界说了一个结构体entsize_list_tt，它内部包括一个嵌套的结构体iteratorImpl，用于完成一个迭代器。遍历容器（如列表、数组等）的目标。

到此能够得出ivars 是一个 ivar_list_t 数组，它存储了类的特点变量信息，那protocol_list_t结构体内部也是数组形式构建的。

baseProtocols，baseProperties 这两个特点对类的存储信息只能读取，不能写入。

所以总结的是：从 class_ro_t 结构体界说来看，它存储类的变量，办法，协议信息，而且这个结构体归于类的只读信息，它包括了类的初始信息。

class_rw_ext_t

这个结构体不在过多叙述，简略来说它是根据 class_rw_t 之后为了更好管理oc类的高级特性，比方关联特点等，衍生出来的一个结构体，包括：method_array_t ,property_arrat_t ,protocol_array_t 等界说特点类型

到这儿类结构及存储所关联的信息都在这儿了；来一张他们关联的结构思维图：

总结：一开始编译时，程序将类的初始信息放在 class_ro_t中，当程序运行时，将类的信息兼并在一起的时分，它会将 class_ro_t 类的信息兼并到 class_rw_t 结构体中去。

struct method_t

为什么要说method_t，因为它不只在 class_ro_t 有运用，在OC底层其他当地也有运用；比方如下源码：

void method_exchangeImplementations(Method m1Signed, Method m2Signed)
{
    if (!m1Signed  ||  !m2Signed) return;
    method_t *m1 = _method_auth(m1Signed);
    method_t *m2 = _method_auth(m2Signed);
    mutex_locker_t lock(runtimeLock);
    IMP imp1 = m1->imp(false);
    IMP imp2 = m2->imp(false);
    SEL sel1 = m1->name();
    SEL sel2 = m2->name();
    m1->setImp(imp2);
    m2->setImp(imp1);
    // RR/AWZ updates are slow because class is unknown
    // Cache updates are slow because class is unknown
    // fixme build list of classes whose Methods are known externally?
    flushCaches(nil, __func__, [sel1, sel2, imp1, imp2](Class c){
        return c->cache.shouldFlush(sel1, imp1) || c->cache.shouldFlush(sel2, imp2);
    });
    adjustCustomFlagsForMethodChange(nil, m1);
    adjustCustomFlagsForMethodChange(nil, m2);
}
static IMP
_method_setImplementation(Class cls, method_t *m, IMP imp)
{
    lockdebug::assert_locked(&runtimeLock);
    if (!m) return nil;
    if (!imp) return nil;
    IMP old = m->imp(false);
    SEL sel = m->name();
    m->setImp(imp);
    // Cache updates are slow if cls is nil (i.e. unknown)
    // RR/AWZ updates are slow if cls is nil (i.e. unknown)
    // fixme build list of classes whose Methods are known externally?
    flushCaches(cls, __func__, [sel, old](Class c){
        return c->cache.shouldFlush(sel, old);
    });
    adjustCustomFlagsForMethodChange(cls, m);
    return old;
}

办法交流，完成中底层都有用到，咱们探究下，先看看 method_t 源码：

struct method_t {
    // The representation of a "big" method. This is the traditional
    // representation of three pointers storing the selector, types
    // and implementation.
    struct big {
        SEL name;
        const char *types;
        MethodListIMP imp;
    };
    // A "big" method, but name is signed. Used for method lists created at runtime.
    struct bigSigned {
        SEL __ptrauth_objc_sel name;
        const char * ptrauth_method_list_types types;
        MethodListIMP imp;
    };
    // ***HACK: This is a TEMPORARY HACK FOR EXCLAVEKIT. It MUST go away.
    // rdar://96885136 (Disallow insecure un-signed big method lists for ExclaveKit)
#if TARGET_OS_EXCLAVEKIT
    struct bigStripped {
        SEL name;
        const char *types;
        MethodListIMP imp;
    };
#endif
}

能够看到这结构体中掐套了多个结构体；在把它简化下：

struct method_t {
    SEL name;//办法名
    const char *types;//包括函数具有参数编码的字符串类型的返回值
    MethodListIMP imp;//函数指针（指向函数地址的指针）
}

SEL ：函数名，没特别的含义；

特点： 1，运用@selector()，sel_registerName()取得 2，运用sel_getName()，NSStringFromSelector()转成字符串 3，不同类中相同名字办法，对应的办法选择器是相同或相等的

底层代码结构：

/// An opaque type that represents a method selector.
typedef struct objc_selector *SEL;

types:包括了函数返回值、参数编码的字符串

能够看到types在值：v16@0:8 ，能够看出name,types,IMP其实都在class_ro_t结构体中，这样的确证明了之前说的；class_ro_t结构体在运行时存储着类的初始状态数据。

v16@0:8阐明下：
v:办法返回类型，这儿说void，
16：第一个参数，
@：id类型第二个参数，
0：第三个参数
: :selector类型
8:第四个参数

那这种types参数又是什么鬼东西，查下了资料这叫：Type Encoding(类型编码) 怎么证明了，运用如下代码：

苹果官网types encoding表格:

IMP 其实便是指向函数的指针，感觉这个就没有必要讲了。

struct cache_t

cache_t 用于 class的办法缓存，对class常调用的办法缓存下来，进步查询功率，这个上之前都已经说过；接下来看看 bucket_t。

struct bucket_t

struct bucket_t {
	cache_key_t _key;//函数名
	IMP _imp;//函数内存地址
}

这种散列表的模型，其实在底层用一个数组展现：

其实它的内部便是一个一维数组，那或许问了，数组莫非它是循环查找吗，其实不然；在它元素超找时，它是拿到你的 函数名 & mask，而这个 mask 便是 cache_t 结构体中的 mask值；核算得到函数在 散列表 存储的索引值，在经过索引拿到函数地址，进行履行。

接下来看个事例：

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    Student *stu=[Student new];
    [stu test];
    [stu test];
    [stu test];
    [stu test];
  }
  return 0;
}

如上办法：当首次调用它会去类目标中查找，在办法履行时，他会放入cache_t 缓存中，当第2次，第三次，第四次时，它就去缓存中查找。

当办法履行后；咱们看到 _mask 是：3，这个3代表了我类中界说了三个函数；而——_occupied 是一个随意的值；它其实代表了换存办法的个数。

那怎么知道办法有缓存了，再持续往下履行：

这时分履行完 test02, _mask的值从 3 变成了 7 ，阐明散列表 bucket_t 做了扩容操作。在这儿bucket_t 元素需求 _mask 个元素，所以终究 bucket_t 从原有的3个元素进行了 2倍 扩容。

在看下办法是否进行缓存：

能够看见当履行完 [stu test02] 时，数据做了扩容，而且扩容的数据运用(null) 进行填充。

在看个事例：

在履行 [stu test] 之前；其实bucket_t 就3个元素，而且存入了 init 办法；

当履行完 [stu test] 之后；就存入 test 办法。

但是注意的当地：它在扩容时对之前的缓存进行铲除。

经过查看源码，咱们知道了它怎么进行铲除操作，

当履行完 [stu test02]; ，[stu test03]; 之后，它先将缓存清空；这时分 init , test 办法被清空，bucket_t扩容完在存储：test02，test03 办法。

那问题又来了，它是怎么快速定位到办法的，然后履行的？接下来看看代码：

能够清楚看见，当我运用 @selector(test03)&stu_cache._mask 就能够得到下标，然后再从 bucket_t 拿到办法。

到这儿 class结构，类的办法缓存到此结束了，从上面也能够思考下：假如自己去完成散列表数组，是不是思路就跟清晰了。

Objective-C之Class底层结构探索

isa 走位图

struct objc_class

cache_t & class_data_bits_t

FAST_DATA_MASK 掩码值

class_rw_t ，class_ro_t，class_rw_ext_t

struct class_ro_t

class_rw_ext_t

struct method_t

struct cache_t

struct bucket_t

谢谢我们！青山不改，绿水长流。后会有期！

作者信息

Objective-C之Class底层结构探索

isa 走位图

struct objc_class

cache_t & class_data_bits_t

FAST_DATA_MASK 掩码值

class_rw_t ，class_ro_t，class_rw_ext_t

struct class_ro_t

class_rw_ext_t

struct method_t

struct cache_t

struct bucket_t

谢谢我们！青山不改，绿水长流。后会有期！

相关文章

DoKit中网络拦截的使用总结

Git实践基础分享

货拉拉货运iOS用户端架构优化实践

Swift JSON/Model库调研

作者信息