Swift语法 -- [17 - 高级运算符]

1.介绍

Swift 提供了一些对值进行更加复杂操作的高级运算符,作为基本运算符的补充，这些运算包括你在 C 或 Objective-C 所熟悉的所有按位和移位运算符。

2.溢出运算符(Overflow Operator)

• Swift的算数运算符出现溢出时会抛出运行时错误
• 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

3.运算符重载(Operator Overload)

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

struct Point {
    var x: Int
    var 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 prefix func - (p: Point) -> Point {
        return 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 {
         return (p1.x == p2.x) && (p1.y == p2.y)
    }
}

var p1 = Point(x: 10, y: 10)
var p2 = Point(x: 20, y: 20)
var p3 = p1 + p2

4.Equatable

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

struct Point : Equatable {

    var x: Int
    var y: Int
    static func == (p1: Point, p2: Point) -> Bool {
        return (p1.x == p2.x) && (p1.y == p2.y)
    }
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(x: 10, y: 10)
print(p1 == p2)

Swift为以下类型提供默认的Equatable 实现
没有关联类型的枚举

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

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

5.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: 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

6. 自定义运算符(Custom Operator)

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

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
}