Swift5.1 - 高级运算符

溢出运算符(Overflow Operator)

Swift 的算数运算符出现溢出时会抛出运行时错误。

Swift有溢出运算符(&-、 &+、&*), 用来支持溢出。(转圈圈)

var min = UInt8.min     // 0
print(UInt8.min)        // 0
print(min &- 1)         // 255
 
var max = UInt8.max
print(UInt8.max)        // 255
print(max &+ 1)         // 0
print(max &* 2)         // 254

运算符重载(Operator Overload)

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

struct  Point {
    var x: Int, y: Int
    
    // 中缀运算符, 如：1 + 2
    static func + (p1: Point, p2: Point) -> Point {  // 运算符重载放到结构体内部必须加static修饰
        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: inout Point, p2: Point) {
        p1 = p1 + p2
    }
    
    // 前缀运算符, 如：++i
    static prefix  func ++ (p: inout Point) -> Point {
        p += Point(x: 1, y: 1)
        return p
    }
    
    // 后缀运算符，如：i++
    static postfix func ++ (p: inout Point) -> Point {
        let tem = p
        p += Point(x: 1, y: 1)
        return tem
    }
    
    static func == (p1: Point, p2: Point) -> Bool {
        (p1.x == p2.x) && (p1.y == p2.y)
    }
}

let p1 = Point(x: 10, y: 20)
let p2 = Point(x: 20, y: 30)
let p3 = p1 + p2  // Point(x: 30, y: 50)

Equatable 协议

要得知两个实例是否等价，一般做法是遵守Equatable协议，重载==运算符(与此同时，等价于重载了!= 运算符)。

Swift 为以下类型提供默认的Equatable的实现

没有关联类型的枚举
只拥有遵守Equatable协议关联类型的枚举。
只拥有遵守Equatable协议存储属性的结构体。

//1. Int 类型默认遵守了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)
print(p1 != p2) 

// 2.只拥有遵守Equatable协议关联类型的枚举
enum Score: Equatable {
    case point(Int)
    case string
}

let score1 = Score.point(10)
let score2 = Score.point(20)

print(score1 == score2)
print(score1 != score2)

// 3. 没有关联类型的枚举	
enum Score {
    case point
    case string
}

let score1 = Score.point
let score2 = Score.string

print(score1 == score2)
print(score1 != score2)

引用类型比较存储的地址是否相同(是否指向同一个对象)，使用恒等运算符===、!==

class Student {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.age = age
        self.name = name
    }
}

let stu1 = Student(name: "longchi", age: 88)
let stu2 = Student(name: "xiaoye", age: 98)
let stu3 = stu1

print(stu1 === stu2) // flase
print(stu1 === stu3) // true
print(stu1 !== stu2) // true

Comparable 协议

想要比较2个实例的大小，一般的做法是：

遵守Comparable协议
重载相应的运算符。

// score大的比较大，若score相等，age小的比较大。
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: Self, rhs: Self) -> Bool {
        (lhs.score > rhs.score) || (lhs.score == rhs.score && lhs.age < rhs.age)
    }
    
    static func <= (lhs: Self, rhs: Self) -> Bool {
        !(lhs > rhs)
    }

    static func >= (lhs: Self, rhs: Self) -> Bool {
        !(lhs < rhs)
    }
}

let stu1 = Student(score: 100, age: 20)
let stu2 = Student(score: 98, age: 18)
let 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

自定义运算符(Custom Operator)

可以自定义新的运算符：在全局作用域使用operator进行声明。

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

precedencegroup 优先级组 {
	associativity: 结合性(left\right\none)
    higherThan: 比谁的优先级高
    lowerThan: 比谁的优先级低
    assignment: true 代表在可选链操作中拥有跟赋值运算符一样的优先级(person?age = getAge(), 如果person为nil, 则getAge方法不会执行)
}

示例：

prefix operator +++
infix operator +- : PlusMinusPrecedence
precedencegroup PlusMinusPrecedence {
    associativity: none  // 结合性none，表示只允许 a +- b, 不允许 a +- b +- c 这样。
    higherThan: AdditionPrecedence  // 比加法的优先级高
    lowerThan: MultiplicationPrecedence  // 比乘法法的优先级低
    assignment: true
}

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 +- (p1: Point, p2: Point) -> Point {
        Point(x: p1.x + p2.x, y: p1.y - p2.y)
    }
    //static func +- (p1: Point?, p2: Point) -> Point {
    //   return Point(x: p1?.x ?? 0 + p2.x, y: p1?.y ?? 0 - p2.y)
    //}
}

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

优先级组 assignment: true的含义，如果person 为nil, 则右边的Point(x: 10, y: 20) 不会执行。如果放开上面的注释就可以了。

Apple 文档参考：