Paste_Image.png

通過這張圖描述了實例對象，類，元類之間的關系；
圖中實線是 super_class 指針，虛線是 isa 指針。
從圖中看出：

• 當發(fā)送一個實例方法的消息時，isa 指針會在這個類的實例方法列表中查找；
• 當發(fā)送一個類方法的消息時，isa 指針會在這個類的 meta-class 的方法列表中查找，meta-class 之所以重要，是因為它存儲著一個類的所有類方法。
• 每個類都會有一個單獨的 meta-class，因為每個類的類方法基本不可能完全相同。

image

[super class] 與 [self class] 的區(qū)別

@implementation Student

- (instancetype)init {
    self = [super init];
    if (self) {
        NSLog(@"%@", NSStringFromClass([self class]));
        NSLog(@"%@", NSStringFromClass([super class]));
    }
    return self;
}
@end

借助 clang 編譯器，會被編譯器轉化為：

static instancetype _I_Student_init(Student * self, SEL _cmd) {
 self = ((Student *(*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Student"))}, sel_registerName("init"));
 if (self) {
  id obj1 = ((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("class"));
  id obj2 = ((Class (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Student"))}, sel_registerName("class"));
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_hj_pwgsq9614nb0vq4zd315tcx80000gn_T_Student_e7cbc1_mi_0,obj1);
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_hj_pwgsq9614nb0vq4zd315tcx80000gn_T_Student_e7cbc1_mi_1,obj2);
 }
 return self;
}

由此可見：
[self class] 編譯器最終轉成 objc_msgSend(self,@selector(class))，消息的接收者是當前所在類的實例對象，這個時候就會去 self 所在類 Student 去查找 class 方法，如果當前類 Student 沒有 class 會向 Student 父類 Person 類找 class 方法，如果 Person 類也沒有找到 class 方法，最終會找到最頂級父類 NSObject 的 class 方法，并調用了 object_getClass(self)，由于消息接收者是 self 當前類實例對象，所以最終 [self class] 輸出 Student；

[super class] 最終編譯器轉化成了 objc_msgSendSuper(struct objc_super *,SEL)

OBJC_EXPORT void objc_msgSendSuper(void /* struct objc_super *super, SEL op, ... */ )

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained Class class;
#else
    __unsafe_unretained Class super_class;
#endif
    /* super_class is the first class to search */
};

objc_super 是一個結構體，結構體里面有兩個指針，一個是接收消息的 receiver，另一個是指向當前類的父類 super_class，通過 super_class 指針從父類的方法列表開始查找 selector，由于消息接收者還是當前類的實例對象 self，那么 objc_msgSendSuper 最后就轉變成，

objc_msgSend(objc_super->receiver, @selector(class))
- (Class)class {
    return object_getClass(self);
}

由于找到了父類 NSObject 里面的 class 方法的 IMP，又因為傳入的入參 objc_super->receiver = self。self 就是 Student，調用 class，所以父類的方法 class 執(zhí)行 IMP 之后，輸出還是 Student，最后輸出兩個都一樣，都是輸出 Student。

isMemberOfClass 和 isKindOfClass 的區(qū)別

+ (BOOL)isMemberOfClass:(Class)cls {
    return object_getClass((id)self) == cls;
}

- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

+ (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

- (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

isKindOfClass：是判斷方法調用者對象的類是否等于傳入的這個類或者其子類；
isMemberOfClass：object_getClass() 取得的是對象的 isa 指針指向的對象，也就是判斷傳入的類對象的元類對象是否與傳入的這個對象相等，所以這個 cls 應該是元類對象才有可能相等，是檢測方法調用者對象的類是否等于傳入的這個類；

objc_getClass 和 object_getClass 的區(qū)別

Class _Nullable objc_getClass(const char * _Nonnull name)
const char * _Nonnull object_getClassName(id _Nullable obj)

• objc_getClass
objc_getClass 參數是類名的字符串，返回的就是這個類的類對象；

• object_getClass
object_getClass 參數是 id 類型，它返回的是這個 id 的 isa 指針所指向的 Class，如果是 instance 對象，返回 class 對象；如果是 class 對象，返回 meta-class 對象；如果是 meta-class 對象，返回 NSObject 的 meta-class 對象；

NSObject

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}
typedef struct objc_class *Class;

萬物皆對象，通過源碼分析，NSObject 里面包含一個 objc_class 結構體類型的 isa 指針；

isa_t

// Class、uintptr_t、結構體公用一塊內存空間，isa_t 是一個 Class、同時是一個 64 位地址 bits、是一個 64 位結構體。
union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;

#if SUPPORT_PACKED_ISA

# if __arm64__
#   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)
    };

# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
#   define ISA_MAGIC_MASK  0x001f800000000001ULL
#   define ISA_MAGIC_VALUE 0x001d800000000001ULL
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 44; // MACH_VM_MAX_ADDRESS 0x7fffffe00000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 8;
#       define RC_ONE   (1ULL<<56)
#       define RC_HALF  (1ULL<<7)
    };

# else
#   error unknown architecture for packed isa
# endif

// SUPPORT_PACKED_ISA
#endif

};

image

isa_t 是一個 union 類型的結構體，其中的 isa_t、cls、 bits 還有結構體共用同一塊地址空間，而 isa 總共會占據 64 位的內存空間。
詞語解析：
nonpointer：代表是否開啟 isa 指針優(yōu)化。nonpointer = 1，代表開啟 isa 指針優(yōu)化Tagged Pointer。
has_assoc：是否有設置過關聯對象，如果沒有，釋放時會更快。
has_cxx_dtor：是否有 C++ 或者 Objc 的析構函數，如果沒有，釋放時會更快。
shiftcls：類指針，存儲著 Class、Meta-Class 對象的內存地址信息，arm64 架構中有 33 位可以存儲類指針，在 __x86_64__ 架構中有 44 位可以存儲類指針。
magic：判斷對象是否初始化完成。
weakly_referenced：是否有被弱引用指向過，如果沒有，釋放時會更快。
deallocating：對象是否正在釋放。
has_sidetable_rc：判斷該對象的引用計數是否過大，如果過大則需要其他哈希表來進行存儲。
extra_rc：存放該對象的引用計數值 -1 后的結果。對象的引用計數超過 1，會存在這個這個里面，如果引用計數為 10，extra_rc 的值就為 9。

注：本文提到的 nonpointer 等同于 indexed，在 objc 最新源碼已改名為 nonpointer。

isa 的初始化

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    assert(!cls->instancesRequireRawIsa());
    assert(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    assert(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa.cls = cls;
    } else {
        assert(!DisableNonpointerIsa);
        assert(!cls->instancesRequireRawIsa());

        isa_t newisa(0);

#if SUPPORT_INDEXED_ISA
        assert(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.shiftcls = (uintptr_t)cls >> 3;
#endif
        isa = newisa;
    }
}

可以看到 nonpointer 是固定傳 true，因為現在 iOS 已經遷移到 64 位系統(tǒng)了，也就是目前邏輯基本直走 else 分支，然后是 SUPPORT_INDEXED_ISA：

#if __ARM_ARCH_7K__ >= 2
#   define SUPPORT_INDEXED_ISA 1
#else
#   define SUPPORT_INDEXED_ISA 0
#endif

SUPPORT_INDEXED_ISA = 1 是另外一種優(yōu)化，用 isa 內 indexcls 存儲著類在類列表內的索引，用于 apple watch 設備。

newisa.bits = ISA_MAGIC_VALUE

這里給 bits 賦初始，ISA_MAGIC_VALUE = 0x001d800000000001ULL，我們把它轉化成二進制：

ISA_MAGIC_VALUE = 0x000001a000000001ULL轉換成二進制是11010000000000000000000000000000000000001

image

isa.shiftcls = (uintptr_t)cls >> 3

將當前地址右移三位的主要原因是用于將 Class 指針中無用的后三位清楚減小內存的消耗，因為類的指針要按照字節(jié)（8 bits）對齊內存，其指針后三位都是沒有意義的 0。

ISA_MASK 分別是通過掩碼的方式獲取 isa 的類指針。

inline Class 
objc_object::ISA() 
{
    assert(!isTaggedPointer()); 
    return (Class)(isa.bits & ISA_MASK);
}

Tagged Pointer

在2013年9月蘋果提出了 Tagged Pointer 的概念，對于64位程序，引入 Tagged Pointer 后，相關邏輯能減少一半的內存占用，以及 3 倍的訪問速度提升，100 倍的創(chuàng)建、銷毀速度提升。
例如，要存儲一個 NSNumber 對象，其值是一個整數。正常情況下，如果這個整數只是一個 NSInteger 的普通變量，那么它所占用的內存是與 CPU 的位數有關，在 32 位 CPU 下占 4 個字節(jié)，在 64 位 CPU 下是占 8 個字節(jié)的。而指針類型的大小通常也是與 CPU 位數相關，一個指針所占用的內存在 32 位 CPU 下為 4 個字節(jié)，在 64 位 CPU 下也是 8 個字節(jié)。如果沒有Tagged Pointer對象，從 32 位機器遷移到 64 位機器中后，雖然邏輯沒有任何變化，但這種 NSNumber、NSDate 一類的對象所占用的內存會翻倍。

image

為了改進上面提到的內存占用和效率問題，蘋果提出了Tagged Pointer對象。由于 NSNumber、NSDate 一類的變量本身的值需要占用的內存大小常常不需要 8 個字節(jié)，拿整數來說，4 個字節(jié)所能表示的有符號整數就可以達到 20 多億（注：2^31=2147483648，另外 1 位作為符號位)，對于絕大多數情況都是可以處理的。

所以我們可以將一個對象的指針拆成兩部分，一部分直接保存數據，另一部分作為特殊標記，表示這是一個特別的指針，不指向任何一個地址。所以，引入了Tagged Pointer對象之后，64 位 CPU 下 NSNumber 的內存圖變成了以下這樣：

image

運行之后，我們得到的結果如下，可以看到，除去最后的數字最末尾的 2 以及最開頭的 0xb，其它數字剛好表示了相應 NSNumber 的值。

2017-08-26 19:58:08.232 TaggedPointer[87063:1919845] number1 Tagged Pointer is 0xb000000000000072
2017-08-26 19:58:08.232 TaggedPointer[87063:1919845] number2 Tagged Pointer is 0xb0000000000006f2
2017-08-26 19:58:08.232 TaggedPointer[87063:1919845] number3 Tagged Pointer is 0xb0000000000022b2

嘗試放一個 8 字節(jié)的長的整數到NSNumber實例中，對于這樣的實例，由于Tagged Pointer無法將其按上面的壓縮方式來保存，那么應該就會以普通對象的方式來保存，我們的實驗代碼如下：

2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] number1 Tagged Pointer is 0xb000000000000072
2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] number2 Tagged Pointer is 0xb0000000000006f2
2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] number3 Tagged Pointer is 0xb0000000000022b2
2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] bigNumber Tagged Pointer is 0x6100000251a0

運行之后，結果如下，驗證了我們的猜測，bigNumber的地址更像是一個普通的指針地址，和它本身的值看不出任何關系。

可見，當 8 字節(jié)可以承載用于表示的數值時，系統(tǒng)就會以Tagged Pointer的方式生成指針，如果 8 字節(jié)承載不了時，則又用以前的方式來生成普通的指針。

蘋果引入Tagged Pointer，不但減少了 64 位機器下程序的內存占用，還提高了運行效率。完美地解決了小內存對象在存儲和訪問效率上的問題。

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() { 
        return bits.data();
    }
}

class_rw_t* data() {
    return (class_rw_t *)(bits & FAST_DATA_MASK);
}

通過源碼分析：
objc_class 里面包含一個 objc_class 結構體類型的 superclass 指針，可以通過 superclass 指針，查找到父類；
cache_t 結構體的 cache 指針，cache 主要用于方法性能優(yōu)化，對使用過的方法進行緩存，便于第二次查找；
class_data_bits_t 結構體的 bits 指針，只含有一個 64 位的 bits 用于存儲與類有關的信息；

在 objc_class 結構體中的注釋寫到 class_data_bits_t 相當于 class_rw_t 指針加上 rr/alloc 的標志。

通過將 bits 與 FAST_DATA_MASK 進行位運算，返回 class_rw_t * 指針，其中 Objc 的類的屬性、方法、以及遵循的協(xié)議都放在 class_rw_t 結構體中；

cache_t

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;

public:
    struct bucket_t *buckets();
    mask_t mask();
    mask_t occupied();
    void incrementOccupied();
    void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask);
    void initializeToEmpty();

    mask_t capacity();
    bool isConstantEmptyCache();
    bool canBeFreed();

    static size_t bytesForCapacity(uint32_t cap);
    static struct bucket_t * endMarker(struct bucket_t *b, uint32_t cap);

    void expand();
    void reallocate(mask_t oldCapacity, mask_t newCapacity);
    struct bucket_t * find(cache_key_t key, id receiver);

    static void bad_cache(id receiver, SEL sel, Class isa) __attribute__((noreturn));
};

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

cache 主要是為了優(yōu)化方法調用的性能，一個接收者對象接收到一個消息時，它會根據 isa 指針去查找能夠響應這個消息的對象。在實際使用中，這個對象只有一部分方法是常用的，很多方法其實很少用或者根本用不上。這種情況下，如果每次消息來時，我們都是 methodLists 中遍歷一遍，性能勢必很差。這時，cache 就派上用場了。在我們每次調用過一個方法后，這個方法就會被緩存到 cache 列表中，下次調用的時候就會優(yōu)先去 cache 中查找，才去 methodLists 中查找方法。

從源碼中可以看出，
_buckets 指針是一個指向 bucket_t 結構體的哈希表，_buckets 哈希表里面包含多個 bucket_t，每個 bucket_t 里面存放著 SEL 和 imp 函數的內存地址的對應關系；
_mask 是一個 uint32_t 的指針，表示整個 _buckets 哈希表的長度；
_occupied 也是一個 uint32_t 的指針，在 _buckets 哈希表中已經緩存的方法數量；

在 bucket_t 結構體中，_key 是一個 unsigned long 的指針，其實是一個被 hash 化的一串數值，就是方法的 sel，也就是方法名；_imp 指針保持著對應的函數地址；

cache_t 如何緩存 sel

void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
    cache_fill_nolock(cls, sel, imp, receiver);
}

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver)
{
    // Never cache before +initialize is done
    // 系統(tǒng)要求在類初始化完成之前，不能進行方法返回，因此如果類沒有完成初始化就 return
    if (!cls->isInitialized()) return;

    // Make sure the entry wasn't added to the cache by some other thread 
    // before we grabbed the cacheUpdateLock.
    // 因為有可能其他線程已經把該方法緩存起來，如果緩存中已經緩存過了，不用再緩存，直接 return
    if (cache_getImp(cls, sel)) return;

    cache_t *cache = getCache(cls);
    cache_key_t key = getKey(sel);

    // Use the cache as-is if it is less than 3/4 full
    mask_t newOccupied = cache->occupied() + 1;
    mask_t capacity = cache->capacity();
    if (cache->isConstantEmptyCache()) {
        // Cache is read-only. Replace it.
        cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
    }
    else if (newOccupied <= capacity / 4 * 3) {
        // Cache is less than 3/4 full. Use it as-is.
    }
    else {
        // Cache is too full. Expand it.
        cache->expand();
    }

    // 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.
    bucket_t *bucket = cache->find(key, receiver);
    if (bucket->key() == 0) cache->incrementOccupied();
    bucket->set(key, imp);
}

void cache_t::expand()
{
    cacheUpdateLock.assertLocked();
    
    uint32_t oldCapacity = capacity();
    uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;

    if ((uint32_t)(mask_t)newCapacity != newCapacity) {
        // mask overflow - can't grow further
        // fixme this wastes one bit of mask
        newCapacity = oldCapacity;
    }

    reallocate(oldCapacity, newCapacity);
}

void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity)
{
    bool freeOld = canBeFreed();

    bucket_t *oldBuckets = buckets();
    bucket_t *newBuckets = allocateBuckets(newCapacity);

    // Cache's old contents are not propagated. 
    // This is thought to save cache memory at the cost of extra cache fills.
    // fixme re-measure this

    assert(newCapacity > 0);
    assert((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);

    setBucketsAndMask(newBuckets, newCapacity - 1);
    
    if (freeOld) {
        cache_collect_free(oldBuckets, oldCapacity);
        cache_collect(false);
    }
}

• 先看緩存中是否已經存在了該方法，如果已經存在，直接return掉；
• 如果緩存是只讀的，則需要重新申請緩存空間；
• 如果存入緩存后的大小小于當前大小的 3/4，則當前緩存大小還可以使用，無需擴容；
• 如果緩存太滿，需要擴容，擴容為原來大小的 2 倍，重新申請緩存空間；

enum {
    INIT_CACHE_SIZE_LOG2 = 2,
    INIT_CACHE_SIZE      = (1 << INIT_CACHE_SIZE_LOG2)
};

如果是首次調用這個函數，會使用一個初始容量值 INIT_CACHE_SIZE 來設定緩存容量；從 INIT_CACHE_SIZE 的定義顯示它的值是 4，也就是說蘋果給 cache_t 設定的初始容量是 4。

• 重新設置哈希表的長度 _mask = newCapacity-1，然后將舊內存釋放掉，清空緩存；
• 當通過 find() 方法返回的 bucket->key() == 0，就說明該位置上是空的，沒有緩存過方法，因此可以進行插入操作 bucket->set(key, imp)，也就是將方法緩存到這個位置上。

注意：傳入 cls 得到緩存列表，如果是 instance 對象，返回 class 對象；如果是 class 對象，返回 meta-class 對象；如果是 meta-class 對象，返回 NSObject 的 meta-class 對象；

cache_t 如何查找 sel

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    // 通過 cache_hash() 計算出 key 值 k 對應的 index 值 begin，用來記錄查詢起始索引；
    mask_t begin = cache_hash(k, m);
    // begin 賦值給 i，用于切換索引
    mask_t i = begin;
    do {
        // 用這個 i 從哈希表取值，如果取出來的 bucket_t 的 key = k，則查詢成功，返回該 bucket_t。
        // 如果 key = 0，說明在索引 i 的位置上還沒有緩存過方法，同樣需要返回該 bucket_t，用于中止緩存查詢。
        if (b[i].key() == 0  ||  b[i].key() == k) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);

    // hack
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)k, cls);
}

static inline mask_t cache_next(mask_t i, mask_t mask) {
    return (i+1) & mask;
}

static inline mask_t cache_next(mask_t i, mask_t mask) {
    return i ? i-1 : mask;
}

cache_t 如何查找 sel，本質上就是根據 key 如何查找 index 的過程；
根據 key 計算出 index 值的這個算法稱作哈希算法，盡可能減少不同的 key 得出相同 index 的情況出現，這種情況被稱作哈希碰撞，同時還要保證得出的 index 值在合理的范圍。index 越大，意味著對應的哈希表的長度越長，這是需要占用實際物理空間的，而內存是有限的。
哈希表是一種通過犧牲一定空間，來換取時間效率的設計思想。

SEL

objc_msgSend函數第二個參數類型為SEL，它是selector在Objc中的表示類型（Swift中是Selector類）。selector是方法選擇器，可以理解為區(qū)分方法的id，而這個id的數據結構是SEL，即表示一個方法的selector的指針。

Paste_Image.png

• 方法的selector用于表示運行時方法的名字，Objective-C在編譯時，會依據每一個方法的名字、參數序列，生成一個唯一的整型標識(int類型的地址)，這個標識就是SEL。
• 在Objective-C中，只要方法名相同，那么方法的SEL就是一樣的，每一個方法都對應著一個SEL，所以在Objective-C中，同一個類中或者這個類的繼承體系中，不能存在2個同名的方法，不同的類可以擁有相同的selector，不同的類的實例對象執(zhí)行相同的selector，會在各自的方法列表中根據selector去尋找對應的IMP。
• 在本質上，SEL只是一個指向方法的指針（被hash化得KEY值），能提高方法的查詢速度。

IMP

IMP實際上是一個函數指針，指向方法實現的首地址。其定義如下：

id (*IMP)(id, SEL, ...)

第一個參數是指向 self 的指針(如果是實例方法，則是類實例的內存地址；如果是類方法，則是指向元類的指針)，第二個參數是方法選擇器( selector )，接下來是方法的實際參數列表。

SEL就是為了查找方法的最終實現IMP的，由于每個方法對應唯一的SEL，因此我們可以通過SEL方便快速準確地獲得它所對應的IMP。

Method

Method是一種代表類中的某個方法的類型。

Paste_Image.png

而objc_method在上面的方法列表中提到過，它存儲了方法名，方法類型和方法實現：

Paste_Image.png

注意：

• 方法名類型為SEL，前面提到過相同名字的方法即使在不同類中定義，它們的方法選擇器也相同。
• 方法類型method_types是個char指針，其實存儲著方法的參數類型和返回值類型。
• method_imp指向了方法的實現，本質上是一個函數指針。

Ivar

Ivar是一種代表類中實例變量的類型。

Paste_Image.png

Paste_Image.png

參考資料
https://www.infoq.cn/article/deep-understanding-of-tagged-pointer/
https://draveness.me/isa