重读 Swift 之二:Operator Declaration(运算符重载)

96
HenryCheng
0.1 2016.09.30 16:53* 字数 1031

一、为什么要重载运算符


我们都知道所谓的运算符平常的也就是 + - * / 之类的,比如我们随便写个 1 + 2 打印肯定输出的是 3 ,那么我们为什么还要重载运算符呢?下面我们就举个例子,如下我定义个结构体

struct Vector {
    
    var x: Int = 0
    var y: Int = 0
    var z: Int = 0
}

然后我们定义两个变量 V1,V2

var V1 = Vector(x: 1, y: 2, z: 3)
var V2 = Vector(x: 4, y: 5, z: 6)

然后我们来写V1 + V2,报错

error

报错 + 不能用于 Vector,这是因为 Vector 是我们自定义的一个结构体,所以编译器不知道我们要用 + 对这个结构体做什么操作。因此,在这里我们就需要用到运算符的重载。

二、如何重载运算符


  • 1、含有两个参数的运算符的重载
    因为运算符是一个函数,比如对于数组的 reduce方法我们就可以如下
let arr = [1, 2, 3, 4]
arr.reduce(0, +)

结果是 10 ,这里的 +就代表了一个函数,所以我们重新写的时候可以如下

func + (left: Vector, right: Vector) -> Vector {
    
    return Vector(x: left.x + right.x, y: left.y + right.y, z: left.z + right.z)
}

这样我们就实现了 + 的重载,上面函数中 left 和 right 两个参数都是 Vector 类型的,一个表示运算符左边的参数一个表示运算符右边的参数(这两个参数是有先后顺序的,由于加法满足加法交换律所以这里体现不出来,有兴趣的可以试一下 - 的重载,这时候就要注意顺序了),然后返回值得类型也是 Vector 类型,再来实现V1 + V2的时候,就发现得到了一个新的 Vector 类型的值

V1 + V2

这里我们就已经完成了 + 这个运算符的重载。当然有兴趣的童鞋还可以试着自己实现 - 或者 * 的重载,这里就不一一举例了。
关于双目运算符的重载,和单目运算符类似,如下

func  += (left: inout Vector, right: Vector) {
    
   left = left + right
}

运行结果


V1
  • 2、含有一个参数的运算符的重载
    照着上面单目运算符的方式我们自己来写个 - 重载例子,如下
func - (vector: Vector) -> Vector {
    
    return Vector(x: -vector.x, y: -vector.y, z: -vector.z)
}

按照我们的逻辑这里取反逻辑上应该是正确的,可是编译会发现报错

error

这里我们就要注意了,和有两个参数的运算符不同的是,只有一个参数的运算符位置是不固定的,这里的 - 可以在前可以在后,所以我们在这里还需要注意运算符的位置

prefix func - (vector: Vector) -> Vector {
    
    return Vector(x: -vector.x, y: -vector.y, z: -vector.z)
}

这里加上一个 prefix 表示前置(后置是 postfix)。这样就可以明确运算符的位置

-V1
  • 3 、比较运算符的重载
    关于比较运算符的重载,顾名思义也是有两个参数的,返回值肯定是个 Bool 类型的,如下重载 == 运算符
func == (left: Vector, right: Vector) -> Bool {
    
    return left.x == right.x && left.y == right.y && left.z == right.z
}

V1 与 V2 的比较

再来看看 > 的重载,逻辑稍微多一点

func > (left: Vector, right: Vector) -> Bool {
    
    if left.x != right.x { return left.x > right.x }
    if left.y != right.y { return left.y > right.y }
    if left.z != right.z { return left.z > right.z }
    //如果上面判断都失败了说明 left == right,所以返回值应该是 false
    return false
}

此时再去比较 V1 和 V2 就会出现你逻辑中的效果。常规的运算符就说到这里,下面我们来看一下自定义运算符的重载。

Tips:对于运算符的重载我们是不能重载 = 的,它是被编译器固定拥有的,在底层它是与内存管理相关的,,我们不能认为的去改变它,这里需要注意一下(或者你可以别把赋值运算 = 看成运算符 +_+)。
注意以下这些标记=->///**/.<(前缀运算符)&??(中缀运算符)>(后缀运算符)!? 是被系统保留的。这些符号不能被重载,也不能用于自定义运算符。

三、自定义运算符的重载


上面我们所说的都是 Swift 中已经存在了的运算符,那么我们能不能自己定义运算符呢?答案是肯定的,在文档中我们可以看到这么一句话

Custom operators can begin with one of the ASCII characters /, =, -, +, !, *, %, <, >, &, |, ^, ?, or ~, or one of the Unicode characters defined in the grammar below 
(which include characters from the *Mathematical Operators*, *Miscellaneous Symbols*, and *Dingbats* Unicode blocks, among others).
 After the first character, combining Unicode characters are also allowed.

意思就是

自定义运算符可以由以下其中之一的 ASCII 字符 /、=、 -、+、!、*、%、<、>、&、|、^、?
 以及~,或者后面语法中规定的任一个 Unicode 字符
(其中包含了*数学运算符*、*零散符号(Miscellaneous Symbols)* 以及印刷符号 (Dingbats) 之类的 Unicode 块)开始。在第一个字符之后,允许使用组合型 Unicode 字符。
  • 1、自定义单目运算符
    所以我们在自定义运算符的时候要注意一下。下面我们就来简单的自定义一个单目运算符 +++,这个运算符的作用呢就是让 Vector 中的每个变量都加 1 ,如下
prefix func +++ (vector: Vector) -> Vector {
    
    return Vector(x: vector.x + 1, y: vector.y + 1, z: vector.z + 1)
}

但是编译的时候会报错,如下

error

这是因为我们没有明确的定义这个 +++,所以编译器不识别。所以我们应该申明一下这个运算符,正确的代码如下

prefix operator +++
prefix func +++ (vector: Vector) -> Vector {
    
    return Vector(x: vector.x + 1, y: vector.y + 1, z: vector.z + 1)
}

在前面我们用 prefix operator +++ 声明前置运算符 +++ ,这样后面就可以用了

var V3 = Vector(x: 1, y: 1, z: 1)
prefix operator +++
prefix func +++ (vector: Vector) -> Vector {
    return Vector(x: vector.x + 1, y: vector.y + 1, z: vector.z + 1)
}
V3+++

如上输出结果就是 Vector(x: 2, y: 2, z: 2),到此,单目运算符的自定义就完成了。

  • 2、自定义双目运算符
    双目运算符的定义和单目运算符的定义类似,但是双目运算符自定义的时候的关键字是 infix,如下
infix operator ** 
func ** (x: Double, y: Double) -> Double {
    return pow(x, y)
}```
上面我们就自定义了一个求平方的双目运算符 `**`,然后我们试试 `2 ** 2`就可以看到结果是 `4.0`。
上面好像没有什么问题了,下面我想算一个平方的平方,拨入 2 的 2次方的 3 次方,照着逻辑应该这样写

2 ** 2 ** 3

但是编译我们会发现报错,如下
![error](http://upload-images.jianshu.io/upload_images/571495-b2e1e315590d0634.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
错误是说我们上面的运算是个非结合性的运算,所谓的结合性(associativity)就是运算的先后顺序,在 Swift 2 中我们都知道还有个优先级(precedence),默认的是 100 ,它的范围是 0~200 ,这个是用来设置运算符优先级的,比如在swift 2.2 中我们完全定义一个求平方运算符就是

infix operator ** { associativity left precedence 120 }
func ** (x: Double, y: Double) -> Double {

return pow(x, y)

}
2 ** 2 ** 3 //结果是64.0

在 Swift 3 中有些变化,如下

precedencegroup ComparativePrecedence {
associativity: right
higherThan: LogicalConjunctionPrecedence
}
infix operator ** : ComparativePrecedence
func ** (x: Double, y: Double) -> Double {

return pow(x, y)

}

  如上我们输入 `2 ** 2 ** 3`,就会发现结果是 256.0,这是因为我们把 associativity 设置成为了 right,所以运算从右边开始,先算 ` 2 ** 3 = 8.0`,然后再是 `2 ** 8.0 = 256.0`,如果我们把 associativity 设置成为了 left,就会发现结果是 64.0。关于更多的 associativity 和 higherThan 或者 lowerThan 之类的可以在下方参考连接中参考,这里就不一一说明了。
差不多运算符重载就到这里了,如果还有什么遗漏,欢迎大家指正!

> 参考:
1、[swift-evolution](https://github.com/apple/swift-evolution/blob/master/proposals/0077-operator-precedence.md)
2、[Operator Declaration](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/operator-declaration)
Swift点滴