Object-C与Swift的RunTime运行机制对比

【注】 文中关于Swift部分转载自欧阳大哥2013的Swift5.0的Runtime机制浅析，为了方便对比学习，我添加了OC RunTime的运行机制。

Objective-C语言是一门以C语言为基础的面向对象编程语言，其提供的运行时(Runtime)机制使得它也可以被认为是一种动态语言。运行时的特征之一就是对象方法的调用是在程序运行时才被确定和执行的。系统提供的开放接口使得我们可以在程序运行的时候执行方法替换以便实现一些诸如系统监控、对象行为改变、Hook等等的操作处理。然而这种开放性也存在着安全的隐患，我们可以借助Runtime在AOP层面上做一些额外的操作，而这些额外的操作因为无法进行管控， 所以有可能会输出未知的结果。

可能是苹果意识到了这个问题，所以在推出的Swift语言中Runtime的能力得到了限制，甚至可以说是取消了这个能力，这就使得Swift成为了一门静态语言。Swift语言中对象的方法调用机制和OC语言完全不同，Swift语言的对象方法调用基本上是在编译链接时刻就被确定的，可以看做是一种硬编码形式的调用实现。

Swfit中的对象方法调用机制加快了程序的运行速度，同时减少了程序包体积的大小。但是从另外一个层面来看当编译链接优化功能开启时反而又会出现包体积增大的情况。Swift在编译链接期间采用的是空间换时间的优化策略，是以提高运行速度为主要优化考虑点。

我将从下面4点进行对比分析

• 1、类中定义的常规方法
• 2、继承父类方法调用
• 3、extension中定义的方法
• 4、成员变量的访问

1、类中定义的常规方法

OC普通方法的调用

一个Class类包含以下几种元素

• 1、isa指针，存储着Class、 Meta-Class 对象的内存地址
• 2、superClass指向父类的指针
• 3、cache方法缓存
• 4、bits具体类的信息

bits & FAST_DATA_MASK 指向一个新的结构体Class_rw_t，里面包含着methods方法列表、properties属性列表、protocols协议列表、class_ro_t类的初始化信息等一些类信息

Class_rw_t里面的methods方法列表、properties属性列表都是二维数组，是可读可写的，包含类的初始内容，分类的内容

class_ro_t里面的baseMethodList，baseProtocols，Ivars，baseProperties是一维数组，是只读的，包含类的初始化内容

methods方法列表是存储的一个个的method_t结构体。method_t是对方法的封装

struct method_t{
	SEL name;//函数名
	const char *types;//编码（返回值类型，参数类型）
	IMP imp;//指向函数的指针（函数地址）
}

IMP代表函数的具体实现

typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...); 

第一个参数是指向self的指针(如果是实例方法，则是类实例的内存地址；如果是类方法，则是指向元类的指针)，第二个参数是方法选择器(selector)

SEL

SEL代表方法名，一般叫做选择器，底层结构跟char *类似

• 可以通过@selector()和sel_registerName()获得
• 可以通过sel_getName()和NSStringFromSelector()转成字符串
• 不同类中相同名字的方法，所对应的方法的选择器是相同的
• 具体实现typedef struct objc_selector *SEL

types

types包含了函数返回值，参数编码的字符串

结构为：返回值 参数1 参数2...参数N

iOS中提供了一个叫做@encode的指令，可以将具体的类型表示成字符串编码

例如

// "i24@0:8i16f20"
// 0id 8SEL 16int 20float  == 24
- (int)test:(int)age height:(float)height

每一个方法都有两个默认参数self和_msg 我们可以查到id类型为@，SEL类型为:

• 1、第一个参数i返回值
• 2、第二个参数@ 是id 类型的self
• 3、第三个参数:是SEL 类型的_msg
• 4、第四个参数i 是Int age
• 5、第五个参数f 是float height

其中加载的数字其实是跟所占字节有关

• 1、24 总共占有多少字节
• 2、@0 是id 类型的self的起始位置为0
• 3、:8 是因为id 类型的self占字节为8，所以SEL 类型的_msg`的起始位置为8

Class内部结构中有一个方法缓存cache_t，用散列表（哈希表）来缓存曾经调用过的方法，可以提高方法的查找速度。

cache_t结构体里面有三个元素

• buckets 散列表，是一个数组，数组里面的每一个元素就是一个bucket_t,bucket_t里面存放两个

  • _key SEL作为key
  • _imp 函数的内存地址

• _mask 散列表的长度

• _occupied已经缓存的方法数量

为什么会用到方法缓存

这张图片是我们方法产找路径，如果我们的一个类有多个父类，需要调用父类方法，他的查找路径为

• 1、先遍历自己所有的方法
• 2、如果在自己类中找不到方法，则遍历父类所有方法，没有查找到调用方法之前，一直重复该动作 如果每一次方法调用都是走这样的步骤，对于系统级方法来说，其实还是比较消耗资源的，为了应对这个情况。出现了方法缓存，调用过的方法，都放在缓存列表中，下次查找方法的时候，现在缓存中查找，如果缓存中查找不到，然后在执行上面的方法查找流程。

散列表结构

散列表的结构大概就像上面那样，数组的下标是通过@selector(方法名)&_mask来求得，具体每一个数组的元素是一个结构体,里面包含两个元素_imp和@selector(方法名)作为的key

一个值与&上一个_mask，得出的结果一定小于等于_mask值，而_mask值为数组长度-1，所以任何时候，也不会越界。

其实这就是散列表的算法，也有一些其他的算法，取余,一个值取余和&的效果是相同的。

Swift普通方法的调用

Swift为每个类都建立了一个被称之为虚表的数组结构，这个数组会保存着类中所有定义的常规成员方法函数的地址。每个Swift类对象实例的内存布局中的第一个数据成员和OC对象相似，保存有一个类似isa的数据成员。isa中保存着Swift类的描述信息。对于Swift类的类描述结构苹果并未公开(也许有我并不知道)，类的虚函数表保存在类描述结构的第0x50个字节的偏移处，每个虚表条目中保存着一个常规方法的函数地址指针。每一个对象方法调用的源代码在编译时就会转化为从虚表中取对应偏移位置的函数地址来实现间接的函数调用。下面是对于常规方法的调用Swift语言源代码和C语言伪代码实现:

////////Swift源代码

//基类定义
class CA {
 open func foo1(_ a:Int){}
 open func foo1(_ a:Int, _ b:Int){}
 open func foo2(){}
}

//扩展
extension CA{
 open func extfoo(){} 
}

//派生类定义
class CB:CA{
 open func foo3(){}
 override open func foo1(_ a:Int){}
}

func testfunc(_ obj:CA){
 obj.foo1(10)
}

func main() {
 let objA = A()
 objA.foo1(10)
 objA.foo1(10,20)
 objA.foo2()
 objA.extfoo()

 let objB = B()
 objB.foo1(10)
 objB.foo1(10,20)
 objB.foo2()
 objB.foo3()
 objB.extfoo()

 testfunc(objA)
 testfunc(objB)
}

////////C伪代码

//...........................................运行时定义部分

//Swift类描述。
struct swift_class {
    ...   //其他的属性，因为这里不关心就不列出了
    //虚函数表刚好在结构体的第0x50的偏移位置。
    IMP vtable[0];
};


//...........................................源代码中类的定义和方法的定义和实现部分


//基类定义
struct CA {
      struct swift_class *isa;
};

//派生类定义
struct CB {
   struct swift_class *isa;
};

//基类CA的方法函数的实现，这里对所有方法名都进行修饰命名
void _$s3XXX2CAC4foo1yySiF(int a){}   //CA类中的foo1
void _$s3XXX2CAC4foo1yySi_SitF(int a, int b){} //CA类中的两个参数的foo1
void _$s3XXX2CAC4foo2yyF(){}   //CA类中的foo2
void _$s3XXX2CAC6extfooyyF(){} //CA类中的extfoo函数  

//派生类CB的方法函数的实现。
void _$s3XXX2CBC4foo1yySiF(int a){}   //CB类中的foo1,重写了基类的方法,但是名字不一样了。
void _$s3XXX2CBC4foo3yyF(){}             //CB类中的foo3

 //构造基类的描述信息以及虚函数表
struct swift_class classCA;
classCA.vtable[3] = {&_$s3XXX2CAC4foo1yySiF, &_$s3XXX2CAC4foo1yySi_SitF, &_$s3XXX2CAC4foo2yyF};

//构造派生类的描述信息以及虚函数表，注意这里虚函数表会将基类的函数也添加进来而且排列在前面。
struct swift_class classCB;
classCB.vtable[4] = {&_$s3XXX2CBC4foo1yySiF, &_$s3XXX2CAC4foo1yySi_SitF, &_$s3XXX2CAC4foo2yyF, &_$s3XXX2CBC4foo3yyF};

void testfunc(A *obj){
   obj->isa->vtable[0](10);   //间接调用实现多态的能力。
}


//...........................................源代码中程序运行的部分

void main(){
   CA *objA = CA.__allocating_init(classCA);
   objA->isa = &classCA;
   asm("mov x20, objA")
   objA->isa->vtable[0](10);
   objA->isa->vtable[1](10,20);
   objA->isa->vtable[2]();
   _$s3XXX2CAC6extfooyyF()

  CB *objB = CB.__allocating_init(classCB);
  objB->isa = &classCB;
  asm("mov x20, objB");
  objB->isa->vtable[0](10);
  objB->isa->vtable[1](10,20);
  objB->isa->vtable[2]();
  objB->isa->vtable[3]();
   _$s3XXX2CAC6extfooyyF();

  testfunc(objA);
  testfunc(objB);

}

从上面的代码中可以看出一些特点：

• 1、Swift类的常规方法中不会再有两个隐藏的参数了，而是和字面定义保持一致。那么问题就来了，方法调用时对象如何被引用和传递呢？在其他语言中一般情况下对象总是会作为方法的第一个参数，在编译阶段生成的机器码中，将对象存放在x0这个寄存器中(本文以arm64体系结构为例)。而Swift则不同，对象不再作为第一个参数来进行传递了，而是在编译阶段生成的机器码中，将对象存放在x20这个寄存器中(本文以arm64体系结构为例)。这样设计的一个目的使得代码更加安全。

• 2、每一个方法调用都是通过读取方法在虚表中的索引获取到了方法函数的真实地址，然后再执行间接调用。在这个过程虚表索引的值是在编译时就确定了，因此不再需要通过方法名来在运行时动态的去查找真实的地址来实现函数调用了。虽然索引的位置在编译时确定的，但是基类和派生类虚表中相同索引处的函数的地址确可以不一致，当派生类重写了父类的某个方法时，因为会分别生成两个类的虚表，在相同索引位置保存不同的函数地址来实现多态的能力。

• 3、每个方法函数名字都和源代码中不一样了，原因在于在编译链接是系统对所有的方法名称进行了重命名处理，这个处理称为命名修饰。之所以这样做是为了解决方法重载和运算符重载的问题。因为源代码中重载的方法函数名称都一样只是参数和返回类型不一样，因此无法简单的通过名字进行区分，而只能对名字进行修饰重命名。另外一个原因是Swift还提供了命名空间的概念，也就是使得可以支持不同模块之间是可以存在相同名称的方法或者函数。因为整个重命名中是会带上模块名称的。下面就是Swift中对类的对象方法的重命名修饰规则： _$s<模块名长度><模块名><类名长度><类名>C<方法名长度><方法名>yy<参数类型1>_<参数类型2>_<参数类型N>F

就比如上面的CA类中的foo1两个同名函数在编译链接时刻就会被分别重命名为：

//这里面的XXX就是你工程模块的名称。
void _$s3XXX2CAC4foo1yySiF(int a){}   //CA类中的foo1
void _$s3XXX2CAC4foo1yySi_SitF(int a, int b){} //CA类中的两个参数的foo1

下面这张图就清晰的描述了Swift类的对象方法调用以及类描述信息。

2、继承父类方法调用

OC继承父类方法调用

OC对象主要可以分为3种

• 1、instance对象（实例对象）：instance实例对象就是通过alloc出来的对象，每次调用alloc都会产生新的instance对象
• 2、class对象（类对象）：每个类的内存中有且只有一个类对象
• 3、meta-class对象（元类对象）：每个类的内存中有且只有一个元类对象 实例对象的存储信息
• isa指针
• 其他成员变量

类对象的存储信息

• isa指针
• superClass指针
• 类的属性信息（@property），类的对象方法信息（method），类的协议信息（protocol），类的成员变量信息（ivar）

元类的存储信息

• isa指针
• superClass指针
• 类的属性信息（@property），类的对象方法信息（method），类的协议信息（protocol），类的成员变量信息（ivar）

元类和类的存储结构是一样的，但是用途不一样

• instance的isa指向class，当调用对象方法时，通过instance的isa找到class，最后找到对象方法的实现进行调用
• class的isa指向meta-class，当调用类方法时，通过class的isa找到meta-class，最后找到类方法

总览图

• 1、instance的isa指向class
• 2、class的isa指向meta-class
• 3、meta-class的isa指向基类的meta-class
• 4、class的superclass指向父类的class，如果没有父类，superclass指向nil
• 5、meta-class的superclass指向父类的meta-class，基类的meta-class的superclass指向基类的class
• 6、instance的调用轨迹：isa找class，方法不存在，就通过superclass找父类
• 7、class调用类方法的轨迹：isa找到meta-class，方法不存在，就通过superclass找父类

Swift继承OC类的派生类并且重写了基类的方法

如果在Swift中的使用了OC类，比如还在使用的UIViewController、UIView等等。并且还重写了基类的方法，比如一定会重写UIViewController的viewDidLoad方法。对于这些类的重写的方法定义信息还是会保存在类的Class结构体中，而在调用上还是采用OC语言的Runtime机制来实现，即通过objc_msgSend来调用。而如果在OC派生类中定义了一个新的方法的话则实现和调用机制就不会再采用OC的Runtime机制来完成了，比如说在UIView的派生类中定义了一个新方法foo，那么这个新方法的调用和实现将与OC的Runtime机制没有任何关系了！

////////Swift源代码

//类定义
class MyUIView:UIView {
    open func foo(){}   //常规方法
    override func layoutSubviews() {}  //重写OC方法
}

func main(){
  let obj = MyUIView()
  obj.layoutSubviews()   //调用OC类重写的方法
  obj.foo()   //调用常规的方法。
}

////////C伪代码

//...........................................运行时定义部分

//OC类的方法结构体
struct method_t {
   SEL name;
   IMP imp;
};

//Swift类描述
struct swift_class {
   ...   //其他的属性，因为这里不关心就不列出了。
   struct method_t  methods[1];
   ...   //其他的属性，因为这里不关心就不列出了。
   //虚函数表刚好在结构体的第0x50的偏移位置。
   IMP vtable[1];
};


//...........................................源代码中类的定义和方法的定义和实现部分

//类定义
struct MyUIView {
     struct swift_class *isa;
}

//类的方法函数的实现
void layoutSubviews(id self, SEL _cmd){}
void foo(){}  //Swift类的常规方法中和源代码的参数保持一致。

//类的描述信息构建，这些都是在编译代码时就明确了并且保存在数据段中。
struct swift_class classMyUIView;
classMyUIView.methods[0] = {"layoutSubviews", &layoutSubviews};
classMyUIView.vtable[0] = {&foo};


//...........................................源代码中程序运行的部分

void main(){
 MyUIView *obj = MyUIView.__allocating_init(classMyUIView);
 obj->isa = &classMyUIView;
 //OC类重写的方法layoutSubviews调用还是用objc_msgSend来实现
 objc_msgSend(obj, @selector(layoutSubviews);
 //Swift方法调用时对象参数被放到x20寄存器中
 asm("mov x20, obj");
 //Swift的方法foo调用采用间接调用实现
 obj->isa->vtable[0]();
}

3、extension中定义的方法

OC分类的原理

对于分类的作用恐怕大家都是知道的吧，我们研究一下分类的实现原理。

首先创建一个person类，然后在创建person类的两个分类Person+eat&Person+Run。 研究原理我们的思路就是

• 1、生成c++文件，查看c++文件中的实现
• 2、如果c++文件中实现介绍的不太具体就去查看源码实现

我们使用xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+eat.m来生成c++代码

我们可以找到分类都包含了哪些东西

struct _category_t {
	const char *name;
	struct _class_t *cls;
	const struct _method_list_t *instance_methods;
	const struct _method_list_t *class_methods;
	const struct _protocol_list_t *protocols;
	const struct _prop_list_t *properties;
};

我们发现里面并没有对方法属性协议等等的具体实现过程，那么我们在去源码中查看一下相关实现过程。

源码解读顺序

• 1、objc-os.mm（runtime初始化的代码）
  • _objc_init
  • map_images
  • map_images_nolock
• 2、objc-runtime-new.mm
  • _read_images
  • remethodizeClass
  • attachCategories
  • attachLists
  • realloc、memmove、 memcpy

我们按照源码查找一路找到attachCategories方法，我们发现这个方法就是对分类的实现。里面第一句解释Attach method lists and properties and protocols from categories to a class.将方法列表、属性和协议从类别附加到类中。

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
	if (!cats) return;
	if (PrintReplacedMethods) printReplacements(cls, cats);
	bool isMeta = cls->isMetaClass();
	//方法数组，这是一个二维数组
	/*
	[
	[method_t,method_t],
	[method_t,method_t]
	]
	*/
	method_list_t **mlists = (method_list_t **)
	malloc(cats->count * sizeof(*mlists));
	//属性数组，这是一个二维数组
	property_list_t **proplists = (property_list_t **)
	malloc(cats->count * sizeof(*proplists));
	//协议数组，这是一个二维数组
	protocol_list_t **protolists = (protocol_list_t **)
	malloc(cats->count * sizeof(*protolists));

	int mcount = 0;
	int propcount = 0;
	int protocount = 0;
	int i = cats->count;
	bool fromBundle = NO;
	while (i--) {
    	//取出某个分类
    	auto& entry = cats->list[i];
    	//取出分类里面的方法列表
    	method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
    	if (mlist) {
    		mlists[mcount++] = mlist;
    		fromBundle |= entry.hi->isBundle();
    	}
    
    	property_list_t *proplist = 
    	entry.cat->propertiesForMeta(isMeta, entry.hi);
    	if (proplist) {
    		proplists[propcount++] = proplist;
    	}
    
    	protocol_list_t *protolist = entry.cat->protocols;
    	if (protolist) {
    		protolists[protocount++] = protolist;
    	}
	}
	//得到对象里面的数据
	auto rw = cls->data();

	prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
	//将所有分类的对象方法，附加到类对象的方法列表中
	rw->methods.attachLists(mlists, mcount);
	free(mlists);
	if (flush_caches  &&  mcount > 0) flushCaches(cls);
	//将所有分类的属性，附加到类对象的属性列表中
	rw->properties.attachLists(proplists, propcount);
	free(proplists);
	//将所有分类的协议，附加到类对象的协议列表中
	rw->protocols.attachLists(protolists, protocount);
	free(protolists);
}

我们发现rw->methods.attachLists(mlists, mcount);方法是实现将所有分类的对象方法，附加到类对象的方法列表中，其他两个属性和协议都是调用这个方法，我们分析一个就可以了。

点击进入attachLists方法，里面有一个段实现代码

if (hasArray()) {
	// many lists -> many lists
	uint32_t oldCount = array()->count;
	uint32_t newCount = oldCount + addedCount;
	setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
	array()->count = newCount;
	//array()->list 原来的方法列表
	memmove(array()->lists + addedCount, array()->lists, 
	oldCount * sizeof(array()->lists[0]));
	//addedList 所有分类的方法列表
	memcpy(array()->lists, addedLists, 
	addedCount * sizeof(array()->lists[0]));
}

• 1、扩容，把类中的方法数组和分类中的方法数组计算出来
• 2、memmove把类中方法放到数组的最后一位
• 3、memcpy把分类中的方法放到数组的前面。

extension中定义的方法

如果是在Swift类的extension中定义的方法(重写OC基类的方法除外)。那么针对这个方法的调用总是会在编译时就决定，也就是说在调用这类对象方法时，方法调用指令中的函数地址将会以硬编码的形式存在。在extension中定义的方法无法在运行时做任何的替换和改变！而且方法函数的符号信息都不会保存到类的描述信息中去。这也就解释了在Swift中派生类无法重写一个基类中extension定义的方法的原因了。因为extension中的方法调用是硬编码完成，无法支持多态！下面的Swift源代码以及C伪代码实现说明了这个情况

////////Swift源代码

//类定义
class CA {
   open func foo(){}
}

//类的extension定义
extension CA {
  open func extfoo(){}
}

func main() {
 let obj = CA()
 obj.foo()
 obj.extfoo()
}

////////C伪代码

//...........................................运行时定义部分


//Swift类描述。
struct  swift_class {
    ...   //其他的属性，因为这里不关心就不列出了。
   //虚函数表刚好在结构体的第0x50的偏移位置。
    IMP vtable[1];
};


//...........................................源代码中类的定义和方法的定义和实现部分


//类定义
struct CA {
      struct  swift_class *isa;
}

//类的方法函数的实现定义
void foo(){}
//类的extension的方法函数实现定义
void extfoo(){}

//类的描述信息构建，这些都是在编译代码时就明确了并且保存在数据段中。
//extension中定义的函数不会保存到虚函数表中。
struct swift_class classCA;
classCA.vtable[0] = {&foo};


//...........................................源代码中程序运行的部分

void main(){
  CA *obj =  CA.__allocating_init(classCA)
  obj->isa = &classCA;
  asm("mov x20, obj");
  //Swift中常规方法foo调用采用间接调用实现
  obj->isa->vtable[0]();
  //Swift中extension方法extfoo调用直接硬编码调用，而不是间接调用实现
  extfoo();
}

【注】extension中是可以重写OC基类的方法，但是不能重写Swift类中的定义的方法。具体原因根据上面的解释就非常清楚了。

4、成员变量的访问

OC成员变量的访问

@property 的本质就是ivar + getter + setter

我们创建一个person类，里面创建一个属性

@property (nonatomic,copy) NSString *name;

打印属性信息

unsigned int count;
objc_property_t *propertyList = class_copyPropertyList([Person class], &count);
for (unsigned int i = 0; i< count; i++)
	{
	const char *name = property_getName(propertyList[i]);
	NSLog(@"__%@",[NSString stringWithUTF8String:name]);
	objc_property_t property = propertyList[i];
	const char *a = property_getAttributes(property);
	NSLog(@"属性信息__%@",[NSString stringWithUTF8String:a]);
}

属性信息中NSString我们是知道了，但是T,C,N,V_name都是什么意思呢。我们查看官方介绍

//T@"NSString",C,N,V_name
//T 类型
//C copy
//N nonatomic
//V 实例变量

方法列表

u_int methodCount;
NSMutableArray *methodList = [NSMutableArray array];
Method *methods = class_copyMethodList([Person class], &methodCount);
for (int i = 0; i < methodCount; i++)
{
	SEL name = method_getName(methods[i]);
	NSString *strName = [NSString stringWithCString:sel_getName(name) encoding:NSUTF8StringEncoding];
	[methodList addObject:strName];
}
free(methods);

NSLog(@"方法列表:%@",methodList);

我们并没有写name&setName:方法，所以这个get和set方法应该就是runtime生成的。

property的实现

property的实现主要是利用runtime的两个方法

class_addProperty(Class _Nullable cls, const char * _Nonnull name,
const objc_property_attribute_t * _Nullable attributes,
unsigned int attributeCount)

void
class_addMethods(Class _Nullable, struct objc_method_list * _Nonnull)

1、class_addProperty 生成属性

/** 
* Adds a property to a class.
* 
* @param cls 修改的类
* @param name 属性名字
* @param attributes 属性数组
* @param attributeCount 属性数组数量
* @return y 成功,n失败
*/
OBJC_EXPORT BOOL class_addProperty(Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount)
 

生成属性

objc_property_attribute_t type = { "T", "@\"NSString\"" };
objc_property_attribute_t ownership = { "C", "" }; // C = copy
objc_property_attribute_t nonatomic = { "N", "" }; //nonatomic
objc_property_attribute_t backingivar  = { "V", "_name" };//V 实例变量
objc_property_attribute_t attrs[] = { type, ownership,nonatomic, backingivar };
class_addProperty([self class], "name", attrs, 4); 

2、class_addMethod 生成方法

NSString *nameGetter(id self, SEL _cmd) {
Ivar ivar = class_getInstanceVariable([self class], "_privateName");
return object_getIvar(self, ivar);
}
void nameSetter(id self, SEL _cmd, NSString *newName) {
Ivar ivar = class_getInstanceVariable([self class], "_privateName");
id oldName = object_getIvar(self, ivar);
if (oldName != newName) object_setIvar(self, ivar, [newName copy]);
}


//其中 “v@:” 表示返回值和参数

if(class_addMethod([self class],  NSSelectorFromString(@"name"), (IMP)nameGetter, "@@:"))
{
	NSLog(@"name get 方法添加成功");
}
else
{
	NSLog(@"name get 方法添加失败");
}

if(class_addMethod([self class], NSSelectorFromString(@"setName:"), (IMP)nameSetter, "v@:@"))
{
	NSLog(@"name set 方法添加成功");
}
else
{
    NSLog(@"name set 方法添加失败");
}

Swift类中成员变量的访问

虽然说OC类和Swift类的对象内存布局非常相似，每个对象实例的开始部分都是一个isa数据成员指向类的描述信息，而类中定义的属性或者变量则一般会根据定义的顺序依次排列在isa的后面。OC类还会为所有成员变量，生成一张变量表信息，变量表的每个条目记录着每个成员变量在对象内存中的偏移量。这样在访问对象的属性时会通过偏移表中的偏移量来读取偏移信息，然后再根据偏移量来读取或设置对象的成员变量数据。在每个OC类的get和set两个属性方法的实现中，对于属性在类中的偏移量值的获取都是通过硬编码来完成，也就是说是在编译链接时刻决定的。

对于Swift来说，对成员变量的访问得到更加的简化。系统会对每个成员变量生成get/set两个函数来实现成员变量的访问。系统不会再为类的成员变量生成变量偏移信息表，因此对于成员变量的访问就是直接在编译链接时确定成员变量在对象的偏移位置，这个偏移位置是硬编码来确定的。下面展示Swift源代码和C伪代码对数据成员访问的实现：

////////Swift源代码

class CA
{
   var a:Int = 10
   var b:Int = 20
}

void main()
{
    let obj = CA()
    obj.b = obj.a
}

////////C伪代码

//...........................................运行时定义部分

//Swift类描述。
struct swift_class {
    ...   //其他的属性，因为这里不关心就不列出了
    //虚函数表刚好在结构体的第0x50的偏移位置。
    IMP vtable[4];
};


//...........................................源代码中类的定义和方法的定义和实现部分

//CA类的结构体定义也是CA类对象在内存中的布局。
struct CA
{
   struct swift_class *isa;
   long  reserve;   //这里的值目前总是2
   int a;
   int b;
};

//类CA的方法函数的实现。
int getA(){
    struct CA *obj = x20;   //取x20寄存器的值，也就是对象的值。
    return obj->a;
}
void setA(int a){
 struct CA *obj = x20;   //取x20寄存器的值，也就是对象的值。
 obj->a = a;
}
int getB(){
    struct CA *obj = x20;   //取x20寄存器的值，也就是对象的值。
    return obj->b;
}
void setB(int b){
 struct CA *obj = x20;   //取x20寄存器的值，也就是对象的值。
 obj->b = b;
}

struct swift_class classCA;
classCA.vtable[4] = {&getA,&setA,&getB, &setB};


//...........................................源代码中程序运行的部分

void main(){
   CA *obj =  CA.__allocating_init(classCA);
   obj->isa = &classCA;
   obj->reserve = 2;
   obj->a = 10;
   obj->b = 20;
   asm("mov x20, obj");
   obj->isa->vtable[3](obj->isa->vtable[0]());  // obj.b = obj.a的实现
}

从上面的代码可以看出，Swift类会为每个定义的成员变量都生成一对get/set方法并保存到虚函数表中。所有对对象成员变量的方法的代码都会转化为通过虚函数表来执行get/set相对应的方法。 下面是Swift类中成员变量的实现和内存结构布局图：

补充

Swift 类的方法以及全局函数

Swift类中定义的类方法和全局函数一样，因为不存在对象作为参数，因此在调用此类函数时也不会存在将对象保存到x20寄存器中这么一说。同时源代码中定义的函数的参数在编译时也不会插入附加的参数。Swift语言会对所有符号进行重命名修饰，类方法和全局函数也不例外。这也就使得全局函数和类方法也支持名称相同但是参数不同的函数定义。简单的说就是类方法和全局函数就像C语言的普通函数一样被实现和定义，所有对类方法和全局函数的调用都是在编译链接时刻硬编码为函数地址调用来处理的

OC调用Swift类中的方法

如果应用程序是通过OC和Swift两种语言混合开发完成的。那就一定会存在着OC语言代码调用Swift语言代码以及相反调用的情况。对于Swift语言调用OC的代码的处理方法是系统会为工程建立一个桥声明头文件:项目工程名-Bridging-Header.h，所有Swift需要调用的OC语言方法都需要在这个头文件中声明。而对于OC语言调用Swift语言来说，则有一定的限制。因为Swift和OC的函数调用ABI规则不相同，OC语言只能创建Swift中从NSObject类中派生类对象，而方法调用则只能调用原NSObject类以及派生类中的所有方法以及被声明为@objc关键字的Swift对象方法。如果需要在OC语言中调用Swift语言定义的类和方法，则需要在OC语言文件中添加:#import "项目名-Swift.h"。当某个Swift方法被声明为@objc关键字时，在编译时刻会生成两个函数，一个是本体函数供Swift内部调用，另外一个是跳板函数(trampoline)是供OC语言进行调用的。这个跳板函数信息会记录在OC类的运行时类结构中，跳板函数的实现会对参数的传递规则进行转换：把x0寄存器的值赋值给x20寄存器，然后把其他参数依次转化为Swift的函数参数传递规则要求，最后再执行本地函数调用。整个过程的实现如下：

////////Swift源代码

//Swift类定义
class MyUIView:UIView {
  @objc    
  open func foo(){}
}

func main() {
  let obj = MyUIView()
  obj.foo()
}

//////// OC源代码
#import "工程-Swift.h"

void main() {
  MyUIView *obj = [MyUIView new];
  [obj foo];
}

////////C伪代码

//...........................................运行时定义部分

//OC类的方法结构体
struct method_t {
    SEL name;
    IMP imp;
};

//Swift类描述
struct swift_class {
    ...   //其他的属性，因为这里不关心就不列出了。
    struct method_t  methods[1];
    ...   //其他的属性，因为这里不关心就不列出了。
    //虚函数表刚好在结构体的第0x50的偏移位置。
    IMP vtable[1];
};

//...........................................源代码中类的定义和方法的定义和实现部分

//类定义
struct MyUIView {
      struct swift_class *isa;
}

//类的方法函数的实现

//本体函数foo的实现
void foo(){}
//跳板函数的实现
void trampoline_foo(id self, SEL _cmd){
     asm("mov x20, x0");
     self->isa->vtable[0](); //这里调用本体函数foo
}

//类的描述信息构建，这些都是在编译代码时就明确了并且保存在数据段中。
struct swift_class classMyUIView;
classMyUIView.methods[0] = {"foo", &trampoline_foo};
classMyUIView.vtable[0] = {&foo};


//...........................................源代码中程序运行的部分

//Swift代码部分
void main()
{
  MyUIView *obj = MyUIView.__allocating_init(classMyUIView);
  obj->isa = &classMyUIView;
   asm("mov x20, obj");
   //Swift方法foo的调用采用间接调用实现。
   obj->isa->vtable[0]();
}

//OC代码部分
void main()
{
  MyUIView *obj = objc_msgSend(objc_msgSend(classMyUIView, "alloc"), "init");
  obj->isa = &classMyUIView;
  //OC语言对foo的调用还是用objc_msgSend来执行调用。
  //因为objc_msgSend最终会找到methods中的方法结构并调用trampoline_foo 
  //而trampoline_foo内部则直接调用foo来实现真实的调用。
  objc_msgSend(obj, @selector(foo));
}

下面的图形展示了Swift中带@objc关键字的方法实现，以及OC语言调用Swift对象方法的实现

文中关于Swift部分转载自欧阳大哥2013的Swift5.0的Runtime机制浅析，为了方便对比学习，我添加了OC RunTime的运行机制