isa的位置以及它的作用

本文所运行的环境是自己编译好的：配置运行objc4-750和使用

本文所写的项目详见：OCBasicDemo

我们先来看看isa的位置

我们先来在main里面写下如下代码：

#import <objc/runtime.h>

@interface Person:NSObject{
@public
  int _age;
}
-(void)run;
+(void)walk;
@end
@implementation Person
-(void)run{
  NSLog(@"run...");
}

+(void)walk{
  NSLog(@"walk...");
}

@end

struct objc_classA{
  Class isa;
};

int main(int argc, const char * argv[]) {
 @autoreleasepool {
    Person *p =  [[Person alloc]init];//Person的实例对象
      
    Class pClass = object_getClass(p);//Person的类对象
      
    struct  objc_classA *pClassA = (__bridge struct objc_classA *)(pClass);//使用结构体转化，拿到isa
      
    Class metaPClass = object_getClass(pClass);//Person的元类对象
      
    p->_age = 10;
    [p run];
    [Person walk];
      
    NSLog(@"p:%p",p);
    NSLog(@"pClass:%p",pClass);
    NSLog(@"metaPClass:%p",metaPClass);
    NSLog(@"End");//打个断点
  }
  return 0;
}

先来说说o结构体bjc_classA的作用：

• 因为Person的类对象pClass，打印不出isa，所以转为具体的结构体 objc_classA

• 为什么这么写呢：

  我们通过点击Class(command+鼠标左键)进入
  //object.mm
  typedef struct objc_class *Class;
  
  再次点击objc_class入
  //objc-runtime-new.h
  struct objc_class : objc_object {
      //Class ISA;
       Class superclass;
       ...
  }
  我们发现：它继承了objc_object，点击objc_object进入定义，发现
  struct objc_object {
  private:
          isa_t isa;
  public:
          Class ISA();
          Class getIsa();
          ...
   }
  里面有一个isa对象哟
  
  补充：在ISA()方法里面 有一个ISA_MASK宏定义
  inline Class 
  objc_object::ISA() 
  {
  assert(!isTaggedPointer()); 
  #if SUPPORT_INDEXED_ISA
  if (isa.nonpointer) {
      uintptr_t slot = isa.indexcls;
      return classForIndex((unsigned)slot);
  }
  return (Class)isa.bits;
  #else
  return (Class)(isa.bits & ISA_MASK);
  #endif
  }
  
  ISA_MASK定义（command+鼠标左键）
  if __arm64__ --> #define ISA_MASK        0x0000000ffffffff8ULL
  # elif __x86_64__ -->#define ISA_MASK    0x00007ffffffffff8ULL
  
  发现：从64bit开始isa要进行一次位域运算，才能得出真正的isa地址```
  
  

分析：我们在NSLog(@"End");处打个断点

从控制台我们看log

run...
walk...
p:0x101828830
pClass:0x100001270
metaPClass:0x100001248

• 1.实例对象的isa的指针的首地址就是实例对象的首地址

  输入：p/x p 
  结果：(Person *) $0 = 0x0000000101828830
  输入：p/x &(p->isa)
  结果：(Class *) $1 = 0x0000000101828830
  

• 2.类对象的isa的指针的首地址就是类对象的首地址

  输入：p/x pClassA
  结果：(objc_classA *) $5 = 0x0000000100001270
  输入：p/x &(pClassA->isa)
  结果：(Class *) $6 = 0x0000000100001270
  

• 3.元类对象的isa的指针的首地址就是元类对象的首地址(同样的方式可看)

• 4.实例对象的isa指向的是类对象

  输入：p/x p->isa
  结果 ：(Class) $2 = 0x001d800100001271 Person
  输入： p/x 0x001d800100001271 & 0x00007ffffffffff8ULL
  结果：(unsigned long long) $3 = 0x0000000100001270
  输入：p/x pClass
  结果 ：(Class) $4 = 0x0000000100001270 Person
  

• 5.类对象的isa指向的是元类对象

  输入：p/x pClassA->isa
  结果：(Class) $8 = 0x001d800100001249
  输入：p/x 0x001d800100001249 & 0x00007ffffffffff8ULL
  结果：(unsigned long long) $9 = 0x0000000100001248
  输入：p/x metaPClass
  结果：Class) $10 = 0x0000000100001248
  

• 我们在来看看isa到底为什么联系：实例对象、类对象、元类对象（也可以理解为到底有啥作用），接下来我们来分析下：

  • instance的isa指向class：当调用对象方法的时候，通过实例对象的isa找到类对象，最后找到类对象里面的对象方法，然后执行相应的对象方法
  • class的isa指向meta-class:当调用类方法的时候，通过类对象的isa找到元类对象，最后找到元类对象里面的类方法，然后执行相应的类方法
  • 我们通过@property方法写的属性，存在class里的属性表里面
  • 分析：（我们查看源码command+属性左键）

这里就里面的源码进行了简单的简化 （由于里面的源码有大量的代码量）
（感兴趣的可以自己按照源码自己写一个出来）
#ifndef myClassInfo_h
#define myClassInfo_h
# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
# endif

#if __LP64__
typedef uint32_t mask_t;
#else
typedef uint16_t mask_t;
#endif
typedef uintptr_t cache_key_t;

struct bucket_t {
    cache_key_t _key;
    IMP _imp;
};

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

struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
};

struct method_t {
    SEL name;
    const char *types;
    IMP imp;
};

struct method_list_t : entsize_list_tt {
    method_t first;
};

struct ivar_t {
    int32_t *offset;
    const char *name;
    const char *type;
    uint32_t alignment_raw;
    uint32_t size;
};

struct ivar_list_t : entsize_list_tt {
    ivar_t first;
};

struct property_t {
    const char *name;
    const char *attributes;
};

struct property_list_t : entsize_list_tt {
    property_t first;
};

struct chained_property_list {
    chained_property_list *next;
    uint32_t count;
    property_t list[0];
};

typedef uintptr_t protocol_ref_t;
struct protocol_list_t {
    uintptr_t count;
    protocol_ref_t list[0];
};

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;  // instance对象占用的内存空间
#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;
};

struct class_rw_t {
   uint32_t flags;
   uint32_t version;
   const class_ro_t *ro;
   method_list_t * methods;    // 方法列表
   property_list_t *properties;    // 属性列表
   const protocol_list_t * protocols;  // 协议列表
   Class firstSubclass;
   Class nextSiblingClass;
   char *demangledName;
};

#define FAST_DATA_MASK          0x00007ffffffffff8UL
struct class_data_bits_t {
    uintptr_t bits;
public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
};

/* OC对象 */
struct my_objc_object {
    void *isa;
};

/* 类对象 */
struct my_objc_class : my_objc_object {
   Class superclass;
   cache_t cache;
   class_data_bits_t bits;
public:
   class_rw_t* data() {
       return bits.data();
   }
   
   my_objc_class* metaClass() {
       return (my_objc_class *)((long long)isa & ISA_MASK);
   }
};

#endif /* myClassInfo_h */  

我们在main.mm文件里面
 #import <Foundation/Foundation.h>
 #import <objc/runtime.h>
 #import "myClassInfo.h"

@interface Person:NSObject{
@public
    int _age;
}
-(void)run;
+(void)walk;
//@property (nonatomic,strong) NSString *name;
@end

@implementation Person
-(void)run{
    NSLog(@"run...");
}
+(void)walk{
    NSLog(@"walk...");
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p =  [[Person alloc]init];
        
        Class pClass = object_getClass(p);
        
        struct  objc_classA *pClassA = (__bridge struct objc_classA *)(pClass);
        
        Class metaPClass = object_getClass(pClass);
             
        //使用myClassInfo类转化实例对象p
        struct my_objc_class *myP  =(__bridge struct my_objc_class *) p;
        class_rw_t  *myPData = myP->data();
        
        //使用myClassInfo类转化类对象pClass
        struct my_objc_class *myClass  =(__bridge struct my_objc_class *) pClass;
        class_rw_t  *myClassData = myClass->data();
        
        //使用myClassInfo类转化元类对象metaPClass
        struct my_objc_class *myMetaClass  =(__bridge struct my_objc_class *) metaPClass;
        class_rw_t  *myMetaClassData = myMetaClass->data();
        
        NSLog(@"End");
    }
    return 0;
}

我们在NSLog(@"End");处打个断点

发现：
1.鼠标放在myClassData上，会出现对象信息：在myClassData->methods->first.name:发现有一个run对象方法
2.鼠标放在myMetaClassData上，会出现对象信息：在myMetaClassData->methods->first.name:发现有一个walk类方法
3.将：//@property (nonatomic,strong) NSString *name;打开
鼠标放在myMetaClassData上，会出现对象信息：在myClassData->properties->first.name:
发现一个name属性

上面的只是简单的看下：其实从源码看出，下面的图的关系

image

---

补充：我们查看源码可以发现 class、meta-class底层都是struct objec-class（结构图简版见下）

image

友情链接：

• 配置运行objc4-750和使用
• libmalloc-166.200.60之源码编译
• OC对象本质(一)
• OC对象的本质（二）
• OC对象的分类
• isa的位置以及它的作用
• superclass的位置以及它的作用
• isa和superclass的总结
• OCBasicDemo
• 配置运行objc4-750和使用
• libmalloc-166.200.60之源码编译
• RAC