溢出運算符（Overflow Operator）

• Swift的算數(shù)運算符出現(xiàn)溢出時會拋出運行時錯誤
• Swift有溢出運算符（&+、&-、&*），用來支持溢出運算

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

運算符重載（Operator Overload）

• 類、結(jié)構(gòu)體、枚舉可以為現(xiàn)有的運算符提供自定義的實現(xiàn)，這個操作叫做：運算符重載

struct Point {
    var x: Int, y: Int
}

func + (p1: Point, p2: Point) -> Point {
    Point(x: p1.x + p2.x, y: p1.y + p2.y)
}

let p = Point(x: 10, y: 20) + Point(x: 11, y: 22)
print(p) // Point(x: 21, y: 42)

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 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)
}

Equatable

• 要想得知2個實例是否等價，一般做法是遵守Equatable協(xié)議，重載 == 運算符

與此同時，等價于重載了 != 運算符

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

• Swift為以下類型提供默認(rèn)的Equatable實現(xiàn)

沒有關(guān)聯(lián)類型的枚舉
只擁有遵守Equatable協(xié)議關(guān)聯(lián)類型的枚舉
只擁有遵守Equatable協(xié)議存儲屬性的結(jié)構(gòu)體

• 引用類型比較存儲的地址值是否相等（是否引用著同一對象），使用恒等運算符 ===、!==

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)
    }
}

• 要想比較2個實例的大小，一般做法是：

遵守Comparable協(xié)議
重載相應(yīng)的運算符

var stu1 = Student(score: 100, age: 20)
var stu2 = Student(score: 98, age: 18)
var stu3 = Student(score: 100, age: 20)
print(stu1 > stu2)
print(stu1 >= stu2)
print(stu1 >= stu3)
print(stu1 <= stu3)
print(stu2 < stu1)
print(stu2 <= stu1)
/*
 true
 true
 true
 true
 true
 true
 */

自定義運算符（Custom Operator）

• 可以自定義新的運算符：在全局作用域使用operator進(jìn)行聲明

prefix operator 前綴運算符

postfix operator 后綴運算符

infix operator 中綴運算符 ： 優(yōu)先級組

precedencegroup 優(yōu)先級組 {
    associativity: 結(jié)合性(left\right\none)
    higherThan: 比誰的優(yōu)先級高
    lowerThan: 比誰的優(yōu)先級低
    assignment: true 代表在可選鏈操作中擁有跟賦值運算符一樣的優(yōu)先級
}

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

• Apple文檔參考

https://developer.apple.com/documentation/swift/swift_standard_library/operator_declarations

https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#ID380

struct Point {
    var x: Int, y: Int
    static prefix func +++ (point: inout Point) -> Point {
        point = Point(x: point.x + point.x, y: point.y + point.y)
        return point
    }
    static func +- (left: Point, right: Point) -> Point {
        return Point(x: left.x + right.x, y: left.y - right.y)
    }
    static func +- (left: Point?, right: Point) -> Point {
        print("+-")
        return Point(x: left?.x ?? 0 + right.x, y: left?.y ?? 0 - right.y)
    }
}

struct Person {
    var point: Point
}
var person: Person? = nil
person?.point +- Point(x: 10, y: 20)