其实这只是协议中的一个小的知识点，但是个人觉得这是对协议的一种优化，可以拿来学习一下。

swift的协议概念：

OC中也有协议，swift中的协议的作用与OC中基本一样，只是在写法上有一点区别。
我们使用 protocol关键字来定义一个协议。在一个协议中只能存放计算式属性以及方法的声明，而不能对他们进行定义。

协议一般和代理一起使用，协议只是声明一些方法名称和计算式属性，可以认为它就是一种约定，谁遵循了这种约定，谁就实现其中的方法和计算式属性。
关于代理，我们这里不做详述。

首先，我们来看看什么是“写时拷贝”？

写时拷贝
由于协议类型是一种抽象类型，swift在实现它的时候采用了一种十分灵活的机制——写时拷贝。
对于像枚举、结构体这种值类型的对象实例，即便用一个他们所遵循的协议去指向值类型的对象实例，
当协议类型自身或它所指向的对象实例任一方修改了存储式实例属性的值的时候，此时就会发生写时拷贝。
这时，swift会将协议类型对象分配一个新的存储空间，然后将它所指向的值类型的对象实例的当前状态拷贝过去。

概念有些抽象，我们来看看实例吧。

/*
 协议是一种比较灵动的动态类型，根据为它所初始化的对象实例的性质不同，它所采取的拷贝与引用
 策略也会有不同。
 */

protocol P {
    
    func foo()
}

do {
    
    print("\n")
    
    struct TestA: P {
        
        var a: Int = 0
        
        func foo() {
            print("这是一个foo")
            print("a = \(a)")
        }
    }
    
    /// 定义枚举类型，遵守协议P
    enum TestB: Int, P {
        case one = 1, two, three
        
        func foo() {
            print("enum = \(self)")
            print("value = \(self.rawValue)")
        }
    }
    
    var a = TestA()
    // 声明P协议类型的对象p，用a对它初始化
    var p: P = a
    p.foo()
    
    a.a = 10
    p.foo()
    /*
     打印：
     这是一个foo
     a = 0
     这是一个foo
     a = 0
     */
    
   p = TestB.two
   p.foo()
}

结果说明，p对象不受对象a的影响,为什么呢？
因为结构体和枚举都是值类型,值类型和引用类型是不一样的。
执行var p: P = a的时候，系统已经分别给 p开辟了新的空间，所以，改变a，并不会对p造成什么影响。

但是呢，由于协议类型是一种抽象类型，swift在实现它的时候采用了一种灵活的机制，也就是“写时拷贝”。

在上面的例子中，

// 初始化变量a，系统为a分配了内存空间
var a = TestA()

// 声明P协议类型的对象p，用a对它初始化
//这个时候，按照我们原来的理解，应该为p所指向的内容也分配了不同的内存空间，但是这个时候，a和p所指向的内容完全一样，虽然他们是值类型，但是这个时候实际上并没有给p所指向的内容分配空间，而是共享a的数据。
var p: P = a
p.foo()

//这个时候，a发生了改变，与p不再一样，这个时候系统才为p所指向的内容分配了内存空间，与a独立。
a.a = 10
p.foo()

值类型的存放：

image.png

引用类型的存放：

image.png

个人疑问：

在上述实例中分别打印a和p的地址看看，

struct TestA: P {
        
        var a: Int = 0
        
        func foo() {
            print("这是一个foo")
            print("a = \(a)")
        }
    }
    
    /// 定义枚举类型，遵守协议P
    enum TestB: Int, P {
        case one = 1, two, three
        
        func foo() {
            print("enum = \(self)")
            print("value = \(self.rawValue)")
        }
    }
    
    var a = TestA()
    // 声明P协议类型的对象p，用a对它初始化
    var p: P = a
    p.foo()
    
    withUnsafePointer(to: a.foo) {
        print("\($0)")
    }
    withUnsafePointer(to: p.foo) {
        print("\($0)")
    }
    
    withUnsafePointer(to: &a) {
        print("p:\($0)")
    }
    
    withUnsafePointer(to: &p) {
        print("p:\($0)")
    }
    
    a.a = 10
    p.foo()
    
    withUnsafePointer(to: &a) {
        print("\($0)")
    }
    withUnsafePointer(to: &p) {
        print("p:\($0)")
    }

结果：

这是一个foo
a = 0
0x00007ffeefbff4c0
0x00007ffeefbff4a8
p:0x00007ffeefbff520
p:0x00007ffeefbff4f8
这是一个foo
a = 0
0x00007ffeefbff520
p:0x00007ffeefbff4f8
enum = two
value = 2

发现地址并没有相同的，也许是我验证方式不对，但是到底该怎么验证呢？请大神们告知。