首先我们来看一段代码
protocol DrawProtocol {
func draw()
}
class Student: DrawProtocol {
var x: Int = 0
var y: Int = 0
func draw() {
}
}
struct Point: DrawProtocol {
var x: Int = 0
var y: Int = 0
func draw() {
}
}
let p = Point()
let s = Student()
let draws: [DrawProtocol] = [p,s]
那么请问各位看官, draws中存储的是什么呢?
事实上，在这种情况下，变量 draws 中存储的元素是一种特殊的数据类型：Existential Container。因为: 无法确定 p , s 的内存大小!
Existential Container
Existential Container是编译器生成的一种特殊的数据类型，用于管理遵守了相同协议的协议类型。因为这些数据类型的内存空间尺寸不同，使用 Extential Container 进行管理可以实现存储一致性。
结构如下:
首位3个词作为 Value Buffer， 每个词包含8个字节 (存储的可能是值，也可能是指针)
Small Value（存储空间小于等于 Value Buffer），可以直接内联存储在 Value Buffer 中。
Large Value（存储空间大于 Value Buffer），当值的数量大于3个属性或者总尺寸超过valueBuffer的占位，则会在堆区分配内存进行存储，Value Buffer 只存储对应的指针, 指针指向了堆空间 (Swift 采用了 Indirect Storage With Copy-On-Write 技术进行了优化。)
Copy-On-Write 这种技术可以提高内存指针利用率，降低堆区内存消耗，从而实现性能提升。该技术的原理是：拷贝时仅仅拷贝 Extension Container，当修改值时，先检测引用计数，如果引用计数大于 1，则开辟新的堆区内存
1 个词作为 Value Witness Table (管理协议类型的生命周期)
由于协议类型的具体类型不同，其内存布局也不同，Value Witness Table 则是对协议类型的生命周期进行专项管理，从而处理具体类型的初始化、拷贝、销毁。
1 个词作为 Protocol Witness Table (管理协议类型的方法调用)
在 Class 中，基于继承关系的多态是通过 Virtual Table 实现的；在 POP 中，没有继承关系，因为无法使用 Virtual Table 实现基于协议的多态，取而代之的是 Protocol Witness Table。每个结构体会创造Protocol Witness Table表中，内部包含指针，指向方法!
内存分布如下：
1. payload_data_0 = 0x0000000000000004,
2. payload_data_1 = 0x0000000000000000,
3. payload_data_2 = 0x0000000000000000,
4. instance_type = 0x000000010d6dc408 ExistentialContainers`type
metadata for ExistentialContainers.Car,
5. protocol_witness_0 = 0x000000010d6dc1c0
ExistentialContainers protocol witness table for
ExistentialContainers.Car:ExistentialContainers.Drivable
in ExistentialContainers
在Swift编译器中，通过Existential Container实现的伪代码如下：
func drawACopy(local :Drawable) {
local.draw()
}
let val :Drawable = Point()
drawACopy(val)
//existential container的伪代码结构
struct ExistContDrawable {
var valueBuffer:(Int, Int, Int)
var vwt:ValueWitnessTable
var pwt:DrawableProtocolWitnessTable
}
// drawACopy方法生成的伪代码
func drawACopy(val:ExistContDrawable) { //将existential container传入
var local = ExistContDrawable() //初始化container
let vwt = val.vwt //获取value witness table，用于管理生命周期
let pwt = val.pwt //获取protocol witness table，用于进行方法分派
local.type = type
local.pwt = pwt
vwt.allocateBufferAndCopyValue(&local, val) //vwt进行生命周期管理，初始化或者拷贝
pwt.draw(vwt.projectBuffer(&local)) //pwt查找方法，这里说一下projectBuffer，因为不同类型在内存中是不同的（small value内联在栈内，large value初始化在堆内，栈持有指针），所以方法的确定也是和类型相关的，我们知道，查找方法时是通过当前对象的地址，通过一定的位移去查找方法地址。
vwt.destructAndDeallocateBuffer(temp) //vwt进行生命周期管理，销毁内存
}
Protocol Type 存储属性
在Swift中class的实例和属性都存储在堆区，Struct实例在栈区! 如果包含指针属性则存储在堆区，Protocol Type如何存储属性？
小的数据则通过Existential Container内联实现。那么存在堆区的数据，又是如何处理Copy呢？
protocol Drawable { func draw() }
class Point {
var x1: CGFloat = 0
var x2: CGFloat = 0
var y1: CGFloat = 0
var y2: CGFloat = 0
}
struct Student: Drawable {
var p: Point
func draw() { }
}
let s1 = Student(p: Point())
let s2 = s1
将新的Exsitential Container的valueBuffer指向同一个value即创建指针引用，但是如果要改变值怎么办?我们知道Struct值的修改和Class不同，Copy是不应该影响原实例的值的!
这里用到了一个技术叫做Indirect Storage With Copy-On-Write，即优先使用内存指针。通过提高内存指针的使用，来降低堆区内存的初始化。降低内存消耗。在需要修改值的时候，会先检测引用计数检测，如果有大于1的引用计数，则开辟新内存，创建新的实例。在对内容进行变更的时候，会开启一块新的内存。
伪代码如下：
struct Line :Drawable {
var storage : Point
init() {
storage = Point()
}
func draw() { }
mutating func move() {
// 如过存在多份引用，则开启新内存，否则直接修改
if !isUniquelyReferencedNonObjc(&storage) {
storage = Point(storage) //柯里化
}
}
}
这样实现的目的：通过多份指针去引用同一份地址的成本远远低于开辟多份堆内存。
静态多态 Static Polymorphism
protocol Drawable {
func draw()
}
struct Line: Drawable {
var x = 0
func draw() {}
}
struct Point: Drawable {
var y = 0
func draw() {}
}
func drawACopy(local :Drawable) {
local.draw()
}
let line = Line()
drawACopy(line)
let point = Point()
drawACopy(point)
关于 Virtual Table 和 Protocol Witness Table 的区别，个人理解：
它们都是一个记录函数地址的列表（即函数表），只是它们的生成方式是不同的。
对于 Virtual Table，在编译时，子类的函数表是通过对父类函数表进行拷贝、覆写、插入等操作生成的。
对于 Protocol Witness Table，在编译时，函数表是通过识别当前类型对协议的实现，直接生成的。
