IOS----runtime 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();

    }

.........................

}

cache_t cache;  方法缓存； class_data_bits_t bits; 用于获取到具体类的信息。

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;

 

private:

    using ro_or_rw_ext_t = objc::PointerUnion<const class_ro_t *, class_rw_ext_t *>;

。。。。。

}

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;

        }

    }

};

 

struct class_rw_ext_t {

    const class_ro_t *ro;

    method_array_t methods;

    property_array_t properties;

    protocol_array_t protocols;

    char *demangledName;

    uint32_t version;

};

二维数组

class method_array_t :

    public list_array_tt<method_t, method_list_t>

{

    typedef list_array_tt<method_t, method_list_t> Super;

 

public:

    method_array_t() : Super() { }

    method_array_t(method_list_t *l) : Super(l) { }

 

    method_list_t * const *beginCategoryMethodLists() const {

        return beginLists();

    }

    

    method_list_t * const *endCategoryMethodLists(Class cls) const;

 

    method_array_t duplicate() {

        return Super::duplicate<method_array_t>();

    }

};

 

 

class property_array_t :

    public list_array_tt<property_t, property_list_t>

{

    typedef list_array_tt<property_t, property_list_t> Super;

 

public:

    property_array_t() : Super() { }

    property_array_t(property_list_t *l) : Super(l) { }

 

    property_array_t duplicate() {

        return Super::duplicate<property_array_t>();

    }

};

 

 

class protocol_array_t :

    public list_array_tt<protocol_ref_t, protocol_list_t>

{

    typedef list_array_tt<protocol_ref_t, protocol_list_t> Super;

 

public:

    protocol_array_t() : Super() { }

    protocol_array_t(protocol_list_t *l) : Super(l) { }

 

    protocol_array_t duplicate() {

        return Super::duplicate<protocol_array_t>();

    }

};

 

buck_t是如何进行存入哈希表的

001 首先获取到当前的buckts

002 计算mask

003 sel与mask进行哈希计算得到Key值

004 进行一个循环操作

首先判断是key对应的是否为空 如果为空就直接存入集合，容量增加1

如果是key对应的值存在，就返回

直到下一个位置为空

 

bucket_t *b = buckets();

    mask_t m = capacity - 1;

    mask_t begin = cache_hash(sel, m);

    mask_t i = begin;

 

    // Scan for the first unused slot and insert there.

    // There is guaranteed to be an empty slot because the

    // minimum size is 4 and we resized at 3/4 full.

    do {

        if (fastpath(b[i].sel() == 0)) {

            incrementOccupied();

            b[i].set<Atomic, Encoded>(sel, imp, cls);

            return;

        }

        if (b[i].sel() == sel) {

            // The entry was added to the cache by some other thread

            // before we grabbed the cacheUpdateLock.

            return;

        }

    } while (fastpath((i = cache_next(i, m)) != begin));