类的结构分析

int main(int argc, const char * argv[]) {  
    @autoreleasepool {  
        //ISA_MASK  0x00007ffffffffff8ULL  
        CJLPerson *person = [CJLPerson alloc];  
        CJLTeacher *teacher = [CJLTeacher alloc];  
        NSLog(@"Hello, World! %@ - %@",person,teacher);    
    }  
    return 0;  
}

struct objc_class : objc_object {  
    // Class ISA;   //8字节
    Class superclass;   //Class是由objc_object定义的, 是一个指针, 8字节
    cache_t cache;             // formerly cache pointer and vtable  //结构体要具体分析里面的属性, 分析出来也是8字节
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags  
    class_rw_t *data() const {  
        return bits.data();  
    }  
    void setData(class_rw_t *newData) {  
        bits.setData(newData);  
    }  
    void setInfo(uint32_t set) {  
        ASSERT(isFuture()  ||  isRealized());  
        data()->setFlags(set);  
    }  
    void clearInfo(uint32_t clear) {  
        ASSERT(isFuture()  ||  isRealized());  
        data()->clearFlags(clear);  
    }  
    // set and clear must not overlap  
    void changeInfo(uint32_t set, uint32_t clear) {  
        ASSERT(isFuture()  ||  isRealized());  
        ASSERT((set & clear) == 0);  
        data()->changeFlags(set, clear);  
    }

/// Represents an instance of a class.  
struct objc_object {  
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;  
};

//数组指针  
    int c[4] = {1, 2, 3, 4};  
    int *d = c;  
    NSLog(@"%p -- %p - %p", &c, &c[0], &c[1]);  
    NSLog(@"%p -- %p - %p", d, d+1, d+2);

struct cache_t {  
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED  
    explicit_atomic<struct bucket_t *> _buckets;  //*指针, 占8字节
    explicit_atomic<mask_t> _mask;  //mask_t 是unsigned int 的别名, 占4字节
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16  
    explicit_atomic<uintptr_t> _maskAndBuckets;  //uintptr_t 是一个指针, 8字节
    mask_t _mask_unused;  //mask_t 是unsigned int 的别名, 占4字节
    // How much the mask is shifted by.  
    static constexpr uintptr_t maskShift = 48;   //static 静态类型不存储在结构体中, 所以不算是结构体的内存
    // Additional bits after the mask which must be zero. msgSend  
    // takes advantage of these additional bits to construct the value  
    // `mask << 4` from `_maskAndBuckets` in a single instruction.  
    static constexpr uintptr_t maskZeroBits = 4;  
    // The largest mask value we can store.  
    static constexpr uintptr_t maxMask = ((uintptr_t)1 << (64 - maskShift)) - 1;  
    // The mask applied to `_maskAndBuckets` to retrieve the buckets pointer.  
    static constexpr uintptr_t bucketsMask = ((uintptr_t)1 << (maskShift - maskZeroBits)) - 1;  
    // Ensure we have enough bits for the buckets pointer.  
    static_assert(bucketsMask >= MACH_VM_MAX_ADDRESS, "Bucket field doesn't have enough bits for arbitrary pointers.");  
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4  
    // _maskAndBuckets stores the mask shift in the low 4 bits, and  
    // the buckets pointer in the remainder of the value. The mask  
    // shift is the value where (0xffff >> shift) produces the correct  
    // mask. This is equal to 16 - log2(cache_size).  
    explicit_atomic<uintptr_t> _maskAndBuckets;  
    mask_t _mask_unused;  
    static constexpr uintptr_t maskBits = 4;  
    static constexpr uintptr_t maskMask = (1 << maskBits) - 1;  
    static constexpr uintptr_t bucketsMask = ~maskMask;  
#else  
#error Unknown cache mask storage type.  
#endif  
#if __LP64__  
    uint16_t _flags;  //uint16_t 是unsigned short的别名 占2个字节
#endif  
    uint16_t _occupied;  //uint16_t 是unsigned short的别名 占2个字节