一、Object（objc实例对象），Class（类），Metaclass（元类），Rootclass(根类)，Rootclass‘s metaclass(根元类)
要理解iOS中的isa指针，我们就离不开Objective-C中类的几种数据结构；在Objective-C的类型结构中，Object（实例），Class（类），Metaclass（元类），Rootclass(根类)，Rootclass‘s metaclass(根元类)，且这些都是对象。
看一下Objective-C对象模型图帮助理解：
Objective-C---->C/C++----->汇编语言---->机器语言；我们知道Objective-C是面向对象语言，其所有的对象都是由其对应的类实例化而来，其实类本身也是一种对象；
在Objective-C中，我们用到的几乎所有类都是NSObject类的子类
我们打开Xcode中#import <objc/runtime.h>头文件中的NSObject.h文件或者苹果公开源码
（苹果官方公开源码objc4源码在线浏览；objc4源码下载，本文使用的objc4-818.2版本）
NSObject类定义格式如下（忽略其方法声明）：
@interface NSObject <NSObject> {
Class isa;
}打开objc.h文件会发现对类（CLass）和实例对象（objc，或者instance）定义如下：
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class; //class类对象
/// Represents an instance of a class.
struct objc_object {
Class _Nonnull isa OBJC_ISA_AVAILABILITY;
};
/// A pointer to an instance of a class.
typedef struct objc_object *id; //objc实例对象Class是一个指向objc_class（类）结构体的指针，而id是一个指向objc_object（实例对象）结构体的指针。
objc_object（实例对象）中isa指针指向的类结构称为objc_class（该对象的类），其中存放着普通成员变量与对象方法 （“-”开头的方法）。
objc_class（类）中isa指针指向的类结构称为metaclass（该类的元类），其中存放着static类型的成员变量与static类型的方法 （“+”开头的方法）。
/// Represents an instance of a class.
struct objc_object {
Class _Nonnull isa OBJC_ISA_AVAILABILITY;
};objc_object（实例对象）结构体中只有isa一个成员属性，指向objc_class（该对象的类）。
在runtime.h文件中
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY; //isa指针，指向metaclass（该类的元类）
#if !__OBJC2__
Class super_class //指向objc_class（该类）的super_class（父类）
const char *name //objc_class（该类）的类名
long version //objc_class（该类）的版本信息，初始化为0，可以通过runtime函数class_setVersion和class_getVersion进行修改和读取
long info //一些标识信息，如CLS_CLASS表示objc_class（该类）为普通类。ClS_CLASS表示objc_class（该类）为metaclass（元类）
long instance_size //objc_class（该类）的实例变量的大小
struct objc_ivar_list *ivars //用于存储每个成员变量的地址
struct objc_method_list **methodLists //方法列表，与info标识关联
struct objc_cache *cache //指向最近使用的方法的指针，用于提升效率
struct objc_protocol_list *protocols //存储objc_class（该类）的一些协议
#endif
} OBJC2_UNAVAILABLE;objc_class（类）比objc_object（实例对象）的结构体中多了很多成员，注释中介绍了各个成员的作用。
因此，我们会发现objc实例对象，类对象，元类，根类，根元类中
1、实例对象（Object）： 我们创建的一个对象或实例objc其实就是一个struct objc_object结构体，这个结构体只有一个成员变量，这是一个Class类型的变量isa，也是一个结构体指针，这个objc对象的isa指针指向他的类对象（即平时我们所说的类）
objc对象在内存中的排布结构体，如下图：
| Objective-C 对象的结构图 |
|---|
| ISA指针 |
| 根类的实例变量 |
| 倒数第二层父类的实例变量 |
| ... |
| 父类的实例变量 |
| 类的实例变量 |
类（CLass）：存储Object实例的相关数据，如：实例方法列表、成员变量列表、属性列表。
元类（Metaclass）：存储Class相关的数据，如：类方法列表、类的信息等。
二、isa指针
我们再看NSObject.mm文件源码，查看一下实例方法 - (CLass)class
// 类方法，返回自身
+ (Class)class {
return self;
}
// 实例方法，查找isa（类）
- (Class)class {
return object_getClass(self);
}我们创建实例对象objc，调用 - (CLass)class，实际就是调用object_getClass方法
我们再点击object_getClass方法看源码定义，在objc-class.mm文件中
/***********************************************************************
* object_getClass.
* Locking: None. If you add locking, tell gdb (rdar://7516456).
**********************************************************************/
Class object_getClass(id obj)
{
if (obj) return obj->getIsa();
else return Nil;
}继续点击getIsa()方法，在objc-object.h文件中
inline Class
objc_object::getIsa()
{
if (fastpath(!isTaggedPointer())) return ISA();
extern objc_class OBJC_CLASS_$___NSUnrecognizedTaggedPointer;
uintptr_t slot, ptr = (uintptr_t)this;
Class cls;
slot = (ptr >> _OBJC_TAG_SLOT_SHIFT) & _OBJC_TAG_SLOT_MASK;
cls = objc_tag_classes[slot];
if (slowpath(cls == (Class)&OBJC_CLASS_$___NSUnrecognizedTaggedPointer)) {
slot = (ptr >> _OBJC_TAG_EXT_SLOT_SHIFT) & _OBJC_TAG_EXT_SLOT_MASK;
cls = objc_tag_ext_classes[slot];
}
return cls;
}可以将其简化成
inline Class
objc_object::getIsa()
{
if (!isTaggedPointer()) return ISA();
return cls;
} 继续点击ISA()方法，在objc-object.h文件中
在苹果官方公开源码objc4-787.1版本中
#if SUPPORT_NONPOINTER_ISA
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
}在苹果官方公开源码objc4-818.2版本中
//objc-object.h文件
inline Class
objc_object::ISA(bool authenticated)
{
ASSERT(!isTaggedPointer());
return isa.getDecodedClass(authenticated);
}
//objc-object.h文件
inline Class
isa_t::getDecodedClass(bool authenticated) {
#if SUPPORT_INDEXED_ISA
if (nonpointer) {
return classForIndex(indexcls);
}
return (Class)cls;
#else
return getClass(authenticated);
#endif
}
//objc-object.h文件
inline Class
isa_t::getClass(MAYBE_UNUSED_AUTHENTICATED_PARAM bool authenticated) {
#if SUPPORT_INDEXED_ISA
return cls;
#else
uintptr_t clsbits = bits;
# if __has_feature(ptrauth_calls)
# if ISA_SIGNING_AUTH_MODE == ISA_SIGNING_AUTH
// Most callers aren't security critical, so skip the
// authentication unless they ask for it. Message sending and
// cache filling are protected by the auth code in msgSend.
if (authenticated) {
// Mask off all bits besides the class pointer and signature.
clsbits &= ISA_MASK;
if (clsbits == 0)
return Nil;
clsbits = (uintptr_t)ptrauth_auth_data((void *)clsbits, ISA_SIGNING_KEY, ptrauth_blend_discriminator(this, ISA_SIGNING_DISCRIMINATOR));
} else {
// If not authenticating, strip using the precomputed class mask.
clsbits &= objc_debug_isa_class_mask;
}
# else
// If not authenticating, strip using the precomputed class mask.
clsbits &= objc_debug_isa_class_mask;
# endif
# else
clsbits &= ISA_MASK;
# endif
return (Class)clsbits;
#endif
}我们都可以将其简化成
inline Class
objc_object::ISA()
{
return (Class)(isa.bits & ISA_MASK);
}追根溯源，我们看到实例方法 - (CLass)class最终获取的即是：结构体objc_object的isa.bits & ISA_MASK
接下来解释一下
1、inline关键字作用
2、在方法objc_object::ISA() 中双冒号::的作用
3、objc_object中的isa
4、isa.bits & ISA_MASK
1、inline关键字
用来定义一个类的内联函数，引入它的主要原因是用它替代C中表达式形式的宏定义。
用inline关键字修饰的是内联函数，内联函数用于替代宏定义。取代宏定义的原因是：
（1）C中使用define这种形式宏定义的原因是因为，C语言是一个效率很高的语言，这种宏定义在形式及使用上像一个函数，但它使用预处理器实现，没有了参数压栈，代码生成等一系列的操作,因此，效率很高，这是它在C中被使用的一个主要原因。
（2）这种宏定义在形式上类似于一个函数，但在使用它时，仅仅只是做预处理器符号表中的简单替换，因此它不能进行参数有效性的检测，也就不能享受C++编译器严格类型检查的好处，另外它的返回值也不能被强制转换为可转换的合适的类型，这样，它的使用就存在着一系列的隐患和局限性。
（3）在C++中引入了类及类的访问控制，这样，如果一个操作或者说一个表达式涉及到类的保护成员或私有成员，你就不可能使用这种宏定义来实现(因为无法将this指针放在合适的位置)。
（4）inline 推出的目的，也正是为了取代这种表达式形式的宏定义，它消除了宏定义的缺点，同时又很好地继承了宏定义的优点。
2、方法objc_object::ISA() 中双冒号::
双冒号::用于表示“域操作符”，例：声明了一个类A，类A里声明了一个成员函数void f()，但没有在类的声明里给出f的定义，那么在类外定义f时，就要写成void A::f()，表示这个f()函数是类A的成员函数。
3、objc_object中的isa指针
根据objc_object的定义，可以知道，isa其实是一个isa_t的对象，继续看isa_t的实现：
union isa_t
{
//这里省略很多变量
}isa_t是个联合体,也就是说：objc_object 中的isa其实是个结构体
4、isa.bits & ISA_MASK
isa是个联合体，其内部的属性bits
union isa_t
{
//省略部分方法和属性...
uintptr_t bits;
}然后看uintptr_t实现：
typedef unsigned long uintptr_t;发现其是个unsigned long类型，ISA_MASK的定义：
# if __arm64__
# define ISA_MASK 0x0000000ffffffff8ULL
# elif __x86_64__
# define ISA_MASK 0x00007ffffffffff8ULL
# else
# error unknown architecture for packed isa
# endif其实ISA_MASK是个数值类型。也就是说判断两个对象是否是同一个class其实是通过比对objc_object中的数值计算后得出的结果是否相等得出的
三、isa指针和Object（objc实例对象），Class（类），Metaclass（元类），Rootclass(根类)，Rootclass‘s metaclass(根元类)之间联系
1、子类，父类实例对象测试代码：
//继承关系： Man : People : NSObject(Man继承自People继承自NSObject)
NSObject *object_instance = [[NSObject alloc]init];
People *people = [[People alloc]init];
Man *man = [[Man alloc]init];
NSLog(@"object_instance---- %p" , object_instance);
NSLog(@"people---- %p" , people);
NSLog(@"man---- %p" , man);三个实例对象的首地址，输出结果：
打印3个实例对象内存内容
根据objc_objectstruct结构得知，对应的内存内容应该为Class 内容，是一个isa，但是这里的isa是经过初始化后的isa(即包含指向Cls的信息和一些其余信息)。我们可以通过& 0x0000000ffffffff8ULL取出对应的isa指向的Class信息如下
对应是的$0 $1 $2就是isa指向的内容，po一下
继续查看类对象的内存分布，对应命令和结果如下
我们会发现
(lldb) x/2gx 0x00007fff800d0660 //NSObject元类地址
0x7fff800d0660: 0x00007fff800d0638 0x0000000000000000 //根元类地址 + 父类地址(=NSObject类对象的地址)
(lldb) x/2gx 0x0000000100728798 //People元类地址
0x100728798: 0x0000000100728770 0x00007fff800d0660 //根元类地址 + 父类地址(=People父类的元类地址)
(lldb) x/2gx 0x0000000100728748 //Man元类地址
0x100728748: 0x0000000100728720 0x0000000100728798 //根元类地址 + 父类地址(=Man父类的元类地址)所有元类的isa都指向NSObject 对应的元类我们称其为根元类
根元类的superclass指针指向NSObject的类对象，其他子元类的superclass指针指向对应父类的元类。
2、实例对象，类对象，元类对象测试代码：
//自定义
struct objc_classA{
Class isa;
};
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
//isa指针，实例对象，类，元类，根类，根元类
[self testISAForObjc];
}
//isa指针，实例对象，类，元类，根类，根元类
- (void)testISAForObjc {
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的元类对象
NSLog(@"p---- %p" , p);
NSLog(@"pClass---- %p" , pClass);
NSLog(@"pClassA---- %p" , pClassA);
NSLog(@"metaPClass---- %p" , metaPClass);
}输出如下：
1、实例对象的isa的指针的首地址就是实例对象的首地址
2、类对象的isa的指针的首地址就是类对象的首地址
3、元类对象的isa的指针的首地址就是元类对象的首地址(同样的方式可看)
4、实例对象的isa指向的是类对象
5、类对象的isa指向的是元类对象
由此我们可看出其实实例、类、元类最主要的链接通道就是他们的isa指针
（一）isa指针的指向（即isa与实例，类，元类之间联系）
一个objc实例对象的isa指针指向他的类对象（即平时我们所说的类），类对象的isa指针指向他的元类，元类的isa指针指向根元类，所有的元类isa都指向同一个根元类，根元类的isa指针指向根元类本身。根元类super class父类指向NSObject类对象。
objc/instance的isa指向class：当调用对象方法的时候，通过实例对象的isa找到类对象，最后找到类对象里面的对象方法，然后执行相应的对象方法
class的isa指向meta-class:当调用类方法的时候，通过类对象的isa找到元类对象，最后找到元类对象里面的类方法，然后执行相应的类方法
总结一下实例对象，类对象以及元类对象之间的isa指向和继承关系的规则为:
1、实例对象的isa指向该类，类的isa指向元类(metaClass)
2、类的superClass指向其父类，如果该类为根类则值为nil
3、元类的isa指向根元类，如果该元类是根元类则指向自身
4、元类的superClass指向父元类，若根元类则指向该根类
（二）isa指针作用
1、调用某个对象的对象方法
它会首先在自身isa指针指向的objc_class(类)的methodLists中查找该方法，如果找不到则会通过objc_class（类）的super_class指针找到其父类，然后从其methodLists中查找该方法，如果仍然找不到，则继续通过 super_class向上一级父类结构体中查找，直至根class
2、调用某个类方法
它会首先通过自己的isa指针找到metaclass（元类），并从其methodLists中查找该类方法，如果找不到则会通过metaclass（元类）的super_class指针找到父类的metaclass（元类）结构体，然后从methodLists中查找该方法，如果仍然找不到，则继续通过super_class向上一级父类结构体中查 找，直至根metaclass（元类）；
注意细节：
运行的时候编译器会将代码转化为objc_msgSend(obj, @selector (makeText))，在objc_msgSend函数中首先通过obj（对象）的isa指针找到obj（对象）对应的class（类）。在class（类）中先去cache中通过SEL（方法的编号）查找对应method（方法），若cache中未找到，再去methodLists中查找，若methodists中未找到，则去superClass中查找，若能找到，则将method（方法）加入到cache中，以方便下次查找，并通过method（方法）中的函数指针跳转到对应的函数中去执行。