1. 溢出运算符

算数运算符中出现溢出时会抛出运行时错误，因此Swift提供了溢出运算符(&+,&-,&*)，支持溢出运算，即使溢出也会正常计算而不是错误

代码：

/*
 1、溢出运算符
 */
var min = UInt8.min
print(min &- 1) // 255, Int8.max

var max = UInt8.max
print(max &+ 1) // 0, Int8.min
print(max &* 2) // 254, 等价于 max &+ max

说明：
1、加减乘三种才可以，除法是不行的（自己后面写博客的时候验证下）
2、溢出时数值是头尾相连来判断的，比如255 &+ 2 = 1。
3、可以通过取余计算，以溢出加法来看，上面的应该等价于(255+2)%256 = 1

本质：

溢出运算符本质.png

可以看到在二进制上的计算其实是正常的计算方式
本质上依然是正常的加减乘，只不过计算后不会报错。如果是正常的加法，255+1，就会进位，此时后面的8位全为0，而进位的1不会报错。

2. 运算符重载

类、结构体、枚举可以为现有的运算符提供自定义的实现，这个操作就叫做运算符重载
代码：

/*
 2、运算符重载
 */
struct Point {
    var x: Int, y: Int
    static func + (p1: Point, p2: Point) -> Point {
        Point(x: p1.x + p2.x, y: p1.y + p2.y)
    }
    static func - (p1: Point, p2: Point) -> Point {
        Point(x: p1.x - p2.x, y: p1.y - p2.y)
    }
    static prefix func - (p: Point) -> Point {
        Point(x: -p.x, y: -p.y)
    }
    static func += (p1: inout Point, p2: Point) {
        p1 = p1 + p2
    }

    static prefix func ++ (p: inout Point) -> Point {
        p += Point(x: 1, y: 1)
        return p
    }
    static postfix func ++ (p: inout Point) -> Point {
        let tmp = p
        p += Point(x: 1, y: 1)
        return tmp
    }
    static func == (p1: Point, p2: Point) -> Bool {
        (p1.x == p2.x) && (p1.y == p2.y)
    }
}

let point1 = Point(x: 1, y: 1)
let point2 = Point(x: 1, y: 1)
print(point1 + point2)//Point(x: 2, y: 2)
print(point1 == point2)//true

说明：

写到类型内，必须需要使用static/class，因为这个运算符是跟类型相关的，而非对象相关的，所以使用static
简单看下写法就好了
重载的运算符只需要看自己重载了什么功能，没有重载的地方仍然和原本的运算符的使用一模一样，在使用上不要有顾虑

3. 常见运算符协议

3.1 Equatable

代码：

/*
 Equatable协议
 */
struct Point : Equatable {
var x: Int, y: Int
}
var p1 = Point(x: 10, y: 20)
var p2 = Point(x: 11, y: 22)
print(p1 == p2) // false
print(p1 != p2) // true

class Person : Equatable {
    var age: Int
    init(age: Int) {
        self.age = age
    }
    static func == (lhs: Person, rhs: Person) -> Bool {
        lhs.age == rhs.age
    }
}
var p1 = Person(age: 10)
var p2 = Person(age: 11)
print(p1 == p2)//false
print(p1 != p2)//true

说明：
1、其实可以不用写Equatable，但是一般要写
2、这个==重载运算符就是Equatable定义的方法
3、Equatable会帮我们重载!= 运算符
4、结构体系统会自行判断比较规则，因此系统会帮我们比较，Person类需要我们自己比较

默认的Equatable实现：
Swift为某些类型默认提供了Equatable实现，其本质就是有约定俗成的比较规则系统就会帮我们实现。如果系统无法自行判断比较规则就不会帮我们实现。

enum Answer : Equatable {
case wrong(Int)
    case right
}
var s1 = Answer.wrong(10)
var s2 = Answer.wrong(20)
print(s1 == s2)

类型：

没有关联类型的枚举
只拥有遵守Equatable协议关联类型的枚举(虽然有关联类型，但是这个关联类型有自己的比较规则了，所以默认会比较)
只拥有遵守Equatable协议存储属性的结构体(结构体的只有存储属性，且所有的存储属性如果遵守比较协议，说明有默认的比较规则，这个结构体也是可以进行比较的)

恒等于运算符

print(p1 === p2)

默认两个对象使用== 比较的是两个对象变量存储的地址值是否相等，但是类中如果重载了 == 运算符，那么只能使用===恒等于运算符来比较两个对象的内存地址是否相等
还有!==是恒不等于运算符

3.2 Comparable

comparable协议提供了比较大小的方法，系统提供的类型已经默认遵守了，如果我们自己的类型想要比较，需要遵守其协议，并且实现其运算符

//Comparable协议
struct Student : Comparable {
    var age: Int
    var score: Int
    init(score: Int, age: Int) {
        self.score = score
        self.age = age
    }
    static func < (lhs: Student, rhs: Student) -> Bool {
        (lhs.score < rhs.score)
        || (lhs.score == rhs.score && lhs.age > rhs.age)
    }
    static func > (lhs: Student, rhs: Student) -> Bool {
        (lhs.score > rhs.score)
        || (lhs.score == rhs.score && lhs.age < rhs.age)
    }
    static func <= (lhs: Student, rhs: Student) -> Bool {
        !(lhs > rhs)
    }
    static func >= (lhs: Student, rhs: Student) -> Bool {
        !(lhs < rhs)
    }
}
var stu1 = Student(score: 100, age: 20)
var stu2 = Student(score: 98, age: 18)
var stu3 = Student(score: 100, age: 20)
print(stu1 > stu2) // true
print(stu1 >= stu2) // true
print(stu1 >= stu3) // true
print(stu1 <= stu3) // true
print(stu2 < stu1) // true
print(stu2 <= stu1) // true

4. 自定义运算符

可以自定义新的运算符实现自己的运算功能

运算符类型：

prefix operator：前缀运算符
postfix operator：后缀运算符
infix operator：中缀运算符 : 优先级组

优先级组：

precedencegroup 优先级组 {
    associativity: 结合性(left\right\none)
    higherThan: 比谁的优先级高
    lowerThan: 比谁的优先级低
    assignment: true代表在可选链操作中拥有跟赋值运算符一样的优先级 
}

实际案例：

prefix operator +++
infix operator +- : PlusMinusPrecedence
precedencegroup PlusMinusPrecedence {
    associativity: none
    higherThan: AdditionPrecedence
    lowerThan: MultiplicationPrecedence
    assignment: true
}