swift重载或自定义操作符

重载运算符

在Swift中，类和结构体是可以提供现有运算符的自定义实现，也就是重载现有运算符。三元运算符（a？b：c）和默认的默认的赋值符(=)是不可重载的

Infix 运算符

单目运算符

下面举个例子来学习下如何重载运算符。

struct Vector2D {
var x = 0.0, y = 0.0
}

这里，首先定义一个结构体Vector2D, 我们要重载 '+', 使得两个同类型结构体相加的结果如下图所示

entension Vector2D {
static func + (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
}

```swift
let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
// combinedVector is a Vector2D instance with values of (5.0, 5.0)

双目运算符

// 这段代码为Vector2D类型提供了比较运算符
extension Vector2D {
static func == (left: Vector2D, right: Vector2D) -> Bool {
return (left.x == right.x) && (left.y == right.y)
}
static func != (left: Vector2D, right: Vector2D) -> Bool {
return !(left == right)
}
}

```swift
let twoThree = Vector2D(x: 2.0, y: 3.0)
let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
if twoThree == anotherTwoThree {
    print("These two vectors are equivalent.")
}
// Prints "These two vectors are equivalent."

Prefix 和 Postfix 运算符

同样的，我们也可以对前缀运算符和后缀运算符进行重载。

// 这段代码为Vector2D类型提供了单目减运算，并且是前缀，也就是取负操作。
extension Vector2D {
static prefix func - (vector: Vector2D) -> Vector2D {
return Vector2D(x: -vector.x, y: -vector.y)
}
}

```swift
let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
// negative is a Vector2D instance with values of (-3.0, -4.0)
let alsoPositive = -negative
// alsoPositive is a Vector2D instance with values of (3.0, 4.0)

值得注意的是，在对前缀运算符或者后缀运算符重载的时候，必须在func关键字后加上prefix或postfix关键字。

组合运算符

组合赋值是其他运算符和赋值运算符一起执行的运算。如+=把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要把运算符的左参数设置成inout，因为这个参数会在运算符函数内直接修改它的值。

extension Vector2D {
static func += (left: inout Vector2D, right: Vector2D) {
left = left + right
}
}

``` swift
var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd
// original now has values of (4.0, 6.0)

自定义运算符

有时候我们需要定义自己的运算符来实现各自需求，在自定义运算符的时候分为两步，声明，实现。

一个新的运算符的声明应该是全局域，并且使用operator关键字声明的，运算符可以使用关键字prefix, infix, postfix，分别声明为前缀，中缀，后缀运算符。

看个例子：

// 在全局域声明一个新的运算符
prefix operator +++


> ```swift
// 实现运算符
extension Vector2D {
    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
        vector += vector
        return vector
    }
}

var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled now has values of (2.0, 8.0)
// afterDoubling also has values of (2.0, 8.0)


此外还可以定义运算符的结合性(associativity)和优先级(precedence)，结合性(associativity)的值可取的值有left，right和none。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。
结合性(associativity)的值默认为none，优先级(precedence)默认为100。

> ```swift
infix operator +- { associativity left precedence 140 }
func +- (left: Vector2D, right: Vector2D) -> Vector2D {
    return Vector2D(x: left.x + right.x, y: left.y - right.y)
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector 此时的值为 (4.0, -2.0)