iOS RunTime之二:类结构

iOS RunTime之二:类结构

IOS小彩虹2021-07-11 6:02:38130A+A-

Paste_Image.png

通过这张图描述了实例对象,类,元类之间的关系; 图中实线是 super_class 指针,虚线是 isa 指针。 从图中看出:

  • 当发送一个实例方法的消息时,isa 指针会在这个类的实例方法列表中查找;
  • 当发送一个类方法的消息时,isa 指针会在这个类的 meta-class 的方法列表中查找,meta-class 之所以重要,是因为它存储着一个类的所有类方法。
  • 每个类都会有一个单独的 meta-class,因为每个类的类方法基本不可能完全相同。

image

[super class] 与 [self class] 的区别

@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 方法,最终会找到最顶级父类 NSObjectclass 方法,并调用了 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 = selfself 就是 Student,调用 class,所以父类的方法 class 执行 IMP 之后,输出还是 Student,最后输出两个都一样,都是输出 Student

isMemberOfClass 和 isKindOfClass 的区别

+ (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:是判断方法调用者对象的类是否等于传入的这个类或者其子类; isMemberOfClassobject_getClass() 取得的是对象的 isa 指针指向的对象,也就是判断传入的类对象的元类对象是否与传入的这个对象相等,所以这个 cls 应该是元类对象才有可能相等,是检测方法调用者对象的类是否等于传入的这个类;

objc_getClass 和 object_getClass 的区别

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 类型,它返回的是这个 idisa 指针所指向的 Class,如果是 instance 对象,返回 class 对象;如果是 class 对象,返回 meta-class 对象;如果是 meta-class 对象,返回 NSObjectmeta-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_tclsbits 还有结构体共用同一块地址空间,而 isa 总共会占据 64 位的内存空间。 词语解析: nonpointer:代表是否开启 isa 指针优化。nonpointer = 1,代表开启 isa 指针优化**Tagged Pointer**。 has_assoc:是否有设置过关联对象,如果没有,释放时会更快。 has_cxx_dtor:是否有 C++ 或者 Objc 的析构函数,如果没有,释放时会更快。 shiftcls:类指针,存储着 ClassMeta-Class 对象的内存地址信息,arm64 架构中有 33 位可以存储类指针,在 __x86_64__ 架构中有 44 位可以存储类指针。 magic:判断对象是否初始化完成。 weakly_referenced:是否有被弱引用指向过,如果没有,释放时会更快。 deallocating:对象是否正在释放。 has_sidetable_rc:判断该对象的引用计数是否过大,如果过大则需要其他哈希表来进行存储。 extra_rc:存放该对象的引用计数值 -1 后的结果。对象的引用计数超过 1,会存在这个这个里面,如果引用计数为 10extra_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 位系统了,也就是目前逻辑基本直走 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 是另外一种优化,用 isaindexcls 存储着类在类列表内的索引,用于 apple watch 设备。

newisa.bits = ISA_MAGIC_VALUE

这里给 bits 赋初始,ISA_MAGIC_VALUE = 0x001d800000000001ULL,我们把它转化成二进制:

ISA_MAGIC_VALUE = 0x000001a000000001ULL转换成二进制是11010000000000000000000000000000000000001

image
也就是 ISA_MAGIC_VALUE 只设置 nonpointer 以及 magic 这两个值。

isa.shiftcls = (uintptr_t)cls >> 3

将当前地址右移三位的主要原因是用于将 Class 指针中无用的后三位清楚减小内存的消耗,因为类的指针要按照字节(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 倍的创建、销毁速度提升。 例如,要存储一个 NSNumber 对象,其值是一个整数。正常情况下,如果这个整数只是一个 NSInteger 的普通变量,那么它所占用的内存是与 CPU 的位数有关,在 32 位 CPU 下占 4 个字节,在 64 位 CPU 下是占 8 个字节的。而指针类型的大小通常也是与 CPU 位数相关,一个指针所占用的内存在 32 位 CPU 下为 4 个字节,在 64 位 CPU 下也是 8 个字节。如果没有Tagged Pointer对象,从 32 位机器迁移到 64 位机器中后,虽然逻辑没有任何变化,但这种 NSNumber、NSDate 一类的对象所占用的内存会翻倍。

image

为了改进上面提到的内存占用和效率问题,苹果提出了Tagged Pointer对象。由于 NSNumber、NSDate 一类的变量本身的值需要占用的内存大小常常不需要 8 个字节,拿整数来说,4 个字节所能表示的有符号整数就可以达到 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 字节的长的整数到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 字节可以承载用于表示的数值时,系统就会以Tagged Pointer的方式生成指针,如果 8 字节承载不了时,则又用以前的方式来生成普通的指针。

苹果引入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 主要用于方法性能优化,对使用过的方法进行缓存,便于第二次查找; class_data_bits_t 结构体的 bits 指针,只含有一个 64 位的 bits 用于存储与类有关的信息;

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

通过将 bitsFAST_DATA_MASK 进行位运算,返回 class_rw_t * 指针,其中 Objc 的类的属性、方法、以及遵循的协议都放在 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 主要是为了优化方法调用的性能,一个接收者对象接收到一个消息时,它会根据 isa 指针去查找能够响应这个消息的对象。在实际使用中,这个对象只有一部分方法是常用的,很多方法其实很少用或者根本用不上。这种情况下,如果每次消息来时,我们都是 methodLists 中遍历一遍,性能势必很差。这时,cache 就派上用场了。在我们每次调用过一个方法后,这个方法就会被缓存到 cache 列表中,下次调用的时候就会优先去 cache 中查找,才去 methodLists 中查找方法。

从源码中可以看出, _buckets 指针是一个指向 bucket_t 结构体的哈希表,_buckets 哈希表里面包含多个 bucket_t,每个 bucket_t 里面存放着 SELimp 函数的内存地址的对应关系; _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
    // 系统要求在类初始化完成之前,不能进行方法返回,因此如果类没有完成初始化就 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 对象,返回 NSObjectmeta-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,它是selectorObjc中的表示类型(Swift中是Selector类)。selector是方法选择器,可以理解为区分方法的id,而这个id的数据结构是SEL,即表示一个方法的selector的指针。

Paste_Image.png

  • 方法的selector用于表示运行时方法的名字,Objective-C在编译时,会依据每一个方法的名字、参数序列,生成一个唯一的整型标识(int类型的地址),这个标识就是SEL
  • Objective-C中,只要方法名相同,那么方法的SEL就是一样的,每一个方法都对应着一个SEL,所以在Objective-C中,同一个类中或者这个类的继承体系中,不能存在2个同名的方法,不同的类可以拥有相同的selector,不同的类的实例对象执行相同的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

参考资料 www.infoq.cn/article/dee… draveness.me/isa

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1

联系我们