在Swift实际开发中，很容易在声明delegate时忽略掉使用weak，这是一个比较严重的问题。现对delegate造成的循环引用的原因及解决办法，还有swift中有关delegate的使用语法进行了一番总结。
关于闭包的循环引用相关问题请看：
Swift闭包循环引用
该文章主要讲解：
- 使用delegate如何造成的循环引用问题
- 怎么使用weak解决循环引用问题
- delegate的一些比较Swift的用法
在这里我模拟一个老师Teacher和学生Student互动的场景，Teacher提问askQuestion Student，Student回答问题giveAnswer，把问题的答案回调delegate给Teacher，最后由Teacher判断答案是否正确judgeIsRightOrNot(answer: Int)
Student.swift文件
protocol StudentDelegate {
func judgeIsRightOrNot(answer: Int)
}
class Student {
var delegate: StudentDelegate?
// 回答问题
func giveAnswer() {
delegate?.judgeIsRightOrNot(answer: 1)
}
deinit {
print("deinit---Student")
}
}
Teacher.swift文件
class Teacher: StudentDelegate {
var student: Student?
init() {
self.student = Student()
self.student?.delegate = self
}
// 提问问题
func askQuestion() {
// 学生回答
student?.giveAnswer()
}
// 判断答案是否正确
func judgeIsRightOrNot(answer: Int) {
if answer == 1 {
print("Right")
} else {
print("Error")
}
}
deinit {
print("deinit---Teacher")
}
}
ViewController.swift文件
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
let teacher = Teacher()
teacher?.askQuestion()
}
deinit {
print("deinit---ViewController")
}
}
ViewController对Teacher是弱引用，viewDidLoad方法执行完之后就不再对Teacher进行引用，Teacher就应该被释放掉了，还有Student也是。
然而运行后却发现，Teacher和Student两者的deinit方法都没走，也就是说这两个对象都没有被释放掉！
Why???
这就回归到了问题的正题，因为delegate是强引用导致的！
来回顾一下代码：
class Teacher {
var student: Student
}
self.student?.delegate = self
第一行代码var student: Student说明teacher是对student进行了强引用
然后第二行代码self.student?.delegate = self表明student.delegate又对teacher进行了强引用，使teacher的retainCount + 1
所以当viewController不对teacher引用后，self.student.delegate却还对teacher强引用着，使得teacher的retainCount = 1，所以teacher不会释放，student同样也无法释放，所以就导致了两者之间相互循环引用！
解决方法
把delegate用weak进行修饰
class Student {
weak var delegate: StudentDelegate?
}
使用weak之后，虽然teacher对student还是强引用，但是self.student.delegate对teacher变成弱引用了，不会再让teacher的retainCount + 1了
因此当ViewController的viewDidLoad执行完毕后，就对teacher不再进行引用，所以teacher的retainCount变成了0后，teacher就被释放了，同样student也就被释放掉了，大家皆大欢喜~
进一步思考一个小问题
如果ViewController中的teacher不是在viewDidLoad中进行声明的，而是一个全局变量呢？当控制器被pop掉后结果会怎样呢，ViewController会被释放吗？
其实我们要搞明白一件事情，就是刚才的teacher和student没被释放是因为它们两者之间相互引用所造成的，而现在ViewController并没有和其他对象构成循环引用，所以在ViewController被pop掉后就立马被释放了，没有什么影响，除非它也像teacher刚才那样与某个对象形成了循环引用关系，retainCount + 1最终才会不被释放。
而对于teacher和student来说，分为以下两种情况：
1) 不使用weak，造成循环引用
既然在viewDidLoad执行完也就是teacher的生命周期结束后都没有被释放，那么即便是控制器被pop掉也依然不会被释放
2) 使用weak，没有被循环引用
既然teacher没有被循环引用，所以在它生命周期结束后（因为是全局变量，所以也就是当ViewController被pop掉内存被释放掉后），teacher不再被其引用，因此会被释放，然后student也会被释放。
所以控制台打印的结果是：
deinit---TwoController
deinit---Teacher
deinit---Student
delegate的相关语法补充
最后在补充一下delegate的相关语法，比如刚才，大家实验一下会发现delegate用weak修饰后，编译报错了。。。
报错原因：
这是因为
Swift的protocol是可以被除了class以外的其他类型遵守的，而对于像struct或enum这样的类型，本身就不通过引用计数来管理内存，所以也不可能用weak这样的ARC的概念来进行修饰。
解决办法：
1）将protocol声明为Objective-C的，这可以通过在protocol前面加上@objc关键字来达到，Objective-C的protocol都只有类能实现，因此使用weak来修饰就合理了。
@objc protocol StudentDelegate {
func judgeIsRightOrNot(answer: Int)
}
2）在protocol声明的名字后边加上class，这可以为编译器显示地指明这个protocol只能由class来实现。
protocol StudentDelegate: class {
func judgeIsRightOrNot(answer: Int)
}
相比起添加
@objc，后一种方法更能表现出问题的实质，同时也避免了过多的不必要的Objective-C兼容。
3）但是在实际开发中，我见很多人在protocol声明的名字后边没有加class，而是加的NSObjectProtocol，我试了一下发现报错了。。
它说Teacher类没有遵守NSObjectProtocol协议，然后我看了下NSObjectProtocol的介绍，如下：
我英语比较烂，看的似懂非懂。。。我感觉它的意思是
StudentDelegate遵循了它，而Teacher类如果要实现StudentDelegate协议，就要继承自NSObject(而UIView、UIViewController则不需要，因为它们本身就继承自NSObject)，我猜的，不知道这么理解对不对，哈哈😁😁。。。如果有知道的大神，敬请指导~
我把Teacher类添加了继承自NSObject，然后把init方法稍微修改了一下，报错消失，编译通过
class Teacher: NSObject, StudentDelegate {
override init() {
super.init()
student = Student()
student?.delegate = self
}
}
代理的可选方法
1）在protocol定义之前加上@objc
原生的
Swift protocol里没有可选项，所有定义的方法都是必须实现的，如果我们想要像Objective-C里那样定义可选的接口方法，就需要将接口本身定义为Objective-C的，也就是在protocol定义之前加上@objc
@objc protocol OptionalProtocol {
@objc optional func optionalMethod() // 可选方法
func necessaryMethod() // 必须实现的方法
}
2）使用protocol extension
使用
@objc修饰的protocol就只能被class实现，这对于struct和enum类型就无法适用了。另外，实现它的class中的方法也必须被标注为@objc，或者整个类就是继承自NSObject，这对写代码就有了一些限制。
还有另一种选择就是使用protocol extension，我们可以在声明一个protocol之后再用extension的方式给出部分方法的默认实现，这样这些方法在实际的类中就是可选实现的了。
protocol OptionalProtocol {
func optionalMethod() // 可选的方法
func necessaryMethod() // 必须实现的方法
}
extension OptionalProtocol {
// 在扩展中给出了默认实现的方法，在实际类中就是可选的了
func optionalMethod() {
print("默认实现")
}
}
