5. Swift 运算符的拓展.png

溢出运算符

  • Swift 的算数运算符出现溢出时会抛出运行时错误
  • Swift 有溢出运算符(&+、&-、&*)，用来支持溢出运算
  1. var min = UInt8.min
  2. print(min &- 1) // 255, Int8.max
  4. var max = UInt8.max
  5. print(max &+ 1) // 0, Int8.min
  6. print(max &* 2) // 254, 等价于 max &+ max

运算符重载

运算符重载：类、结构体、枚举可以为现有的运算符提供自定义的实现

  1. struct Point {
  2.     var x: Int
  3.     var y: Int
  5.     // Point(x: 1, y: 2) + Point(x: 1, y: 2) => Point(x: 2, y: 4)
  6.     static func + (p1: Point, p2: Point) -> Point {
  7.         return Point(x: p1.x + p2.x, y: p1.y + p2.y)
  8.     }
  10.     // Point(x: 1, y: 2) - Point(x: 1, y: 2) => Point(x: 0, y: 0)
  11.     static func - (p1: Point, p2: Point) -> Point {
  12.         return Point(x: p1.x - p2.x, y: p1.y - p2.y)
  13.     }
  15.     // - Point(x: 1, y: 2) => Point(x: -1, y: -2)
  16.     static prefix func - (p: Point) -> Point {
  17.         return Point(x: -p.x, y: -p.y)
  18.     }
  20.     // Point(x: 1, y: 2) += Point(x: 1, y: 2) => Point(x: 2, y: 4)
  21.     static func += (p1: inout Point, p2: Point) {
  22.         p1 = p1 + p2
  23.     }
  25.     // ++ Point(x: 1, y: 2) => Point(x: 2, y: 3)
  26.     static prefix func ++ (p: inout Point) -> Point {
  27.         p += Point(x: 1, y: 1)
  28.         return p
  29.     }
  31.     // Point(x: 1, y: 2) ++ => Point(x: 1, y: 2)
  32.     static postfix func ++ (p: inout Point) -> Point {
  33.         let tmp = p
  34.         p += Point(x: 1, y: 1)
  35.         return tmp
  36.     }
  38.     // Point(x: 1, y: 2) == Point(x: 1, y: 2) => true
  39.     static func == (p1: Point, p2: Point) -> Bool {
  40.          return (p1.x == p2.x) && (p1.y == p2.y)
  41.     }
  42. }
  44. var p1 = Point(x: 10, y: 10)
  45. var p2 = Point(x: 20, y: 20)
  46. var p3 = p1 + p2
  47. print(p3) // Point(x: 30, y: 30)

自定义运算符

不推荐使用自定义运算符，太危险
**
prefix 表示该运算符会位于表达式前面
postfix 表示该运算符会位于表达式后面
infix 表示该操作符会位于两个表达式的中间

  1. prefix operator ~
  2. prefix func ~(v: String?) -> String {
  3.     return v == nil ? "" : v!
  4. }
  6. var a: String?
  7. print(~a)
  1. postfix operator ~
  2. postfix func ~(v: String?) -> String {
  3.     return v == nil ? "" : v!
  4. }
  6. var a: String?
  7. print(a~)

优先级组

precedencegroup 定义了一个优先级组，表示操作符优先级别

  1. precedencegroup YourPrecedenceGroupName {
  2.     /**
  3.      较高优先级组的名称，优先级更高的运算符将优先参与运算
  4.      eg. MultiplicationPrecedence: *(乘) /(除)
  5.      */
  6.     lowerThan: MultiplicationPrecedence
  8.     /**
  9.      较低优先级组的名称，只可以引用当前模块外的优先级组
  10.      eg. AdditionPrecedence: +(加) -(减)
  11.      */
  12.     higherThan: AdditionPrecedence
  14.     /**
  15.      结合性，可选值：left、right、none(默认值)
  16.      比如，减法是左边减去右边，而不是右边减去左边
  17.      */
  18.     associativity: left
  20.     /**
  21.      赋值性，可选值：true、false(默认值)
  22.      */
  23.     assignment: true
  24. }

举例说明

  1. import Darwin
  3. precedencegroup MyPrecedence {
  4.     associativity: left
  5.     higherThan: MultiplicationPrecedence
  6. }
  8. infix operator *^ : MyPrecedence
  10. func *^ (lhs: Double, rhs: Double) -> Double {
  11.     return pow(lhs, rhs)
  12. }
  14. print(2 *^ 4) // 16.0

参考文章