溢出運算符(Overflow Operator)

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

var min = UInt8.min
print(min &- 1)//255
Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
print(min - 1)

var max = UInt8.max

print(max &+ 1)//0
//Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
print(max + 1)

print(max &* 2)//254
//Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
print(max * 2)

運算符重載(Operator Overload)

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

struct Point {
    var x: Int, y:Int
}
func +(p1: Point, p2: Point) -> Point {
    return 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)

• 結(jié)構(gòu)體內(nèi)部重載運算符需要添加關鍵字static

struct Point {
    var x: Int, y:Int
    
    static func + (p1: Point, p2: Point) -> Point {
        return 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)

• prefix和postfix關鍵字

struct Point {
    var x: Int, y:Int
    
    static func + (p1: Point, p2: Point) -> Point {
        return Point(x: p1.x + p2.x,y: p1.y + p2.y)
    }
    
    static func -(p1: Point ,p2: Point) -> Point {
        return Point(x: p1.x - p2.x, y: p1.y - p2.y)
    }
    
    static func +=(p1: inout Point,p2: Point) {
        p1 = p1 + p2
    }
    //需要添加prefix關鍵字
    static prefix func ++(p: inout Point) -> Point {
        p += Point(x: 1, y: 1)
        return p
    }
    //需要添加postfix關鍵字
    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 {
        return (p1.x == p2.x) && (p1.y == p2.y)
    }
}

Equatable

• 要想得知2個實例是否等價,一般做法是遵守Equatable協(xié)議,重載==運算符
• 與此同時,等價于重載了!=運算符
• Swift為一下類型默認提供了Equatable實現(xiàn)
  1.沒有關聯(lián)類型的枚舉
  2.只擁有遵守Equatable協(xié)議關聯(lián)類型的枚舉
  3.只擁有遵守Equatable協(xié)議關聯(lián)類型的結(jié)構(gòu)體
• 引用類型比較存儲地址值是否相等(是否引用著同一個對象),使用恒等運算符=== !==

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

Comparable

• 要想比較兩個實例大小,一般做法是遵守Comparable協(xié)議,重載相應的運算符

//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 {
        return (lhs.score < rhs.score) || (lhs.score == rhs.score && lhs.age > rhs.age)
    }
    
    static func > (lhs: Student,rhs: Student) -> Bool {
        return (lhs.score > rhs.score) || (lhs.score == rhs.score && lhs.age < rhs.age)
    }
    
    static func <= (lhs: Student, rhs: Student) -> Bool {
        return !(lhs > rhs)
    }
    static func >= (lhs: Student, rhs: Student) -> Bool {
        return !(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

自定義運算符(Custom Operator)

• 可以自定義新的運算符:在全局作用域使用operator進行聲明

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參考文檔1
Apple參考文檔2

prefix operator +++
infix operator +- : PlusMinusPrecedence

precedencegroup PlusMinusPrecedence {
    associativity: none
    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 +-(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)