为类和结构体自定义运算符实现

运算符重载

• 类和结构体可以为现有的运算符提供自定义的视线，称为运算符重载

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

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

let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
print(combinedVector)

运行结果如下：
Vector2D(x: 5.0, y: 5.0)

一元运算符重载

• 类与结构体也能提供标准一元运算符的实现
• 要实现前缀或者后缀运算符，需要在声明运算符函数的时候在 func 关键字之前指定 prefix 或者 postfix 限定符。

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

extension Vector2D {
    static prefix func - (vector: Vector2D) -> Vector2D {
        return Vector2D(x: -vector.x, y: -vector.y)
    }
}

let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
let alsoPositive = -negative
print(negative)
print(alsoPositive)

运行结果如下：
Vector2D(x: -3.0, y: -4.0)
Vector2D(x: 3.0, y: 4.0)

组合赋值运算符重载

• 组合赋值运算符将赋值运算符（=）与其他运算符进行结合。
• 在实现的时候，需要把运算符的左参数设置成 inout 类型，因为这个参数的值会在运算符函数内直接被修改

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

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

var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd
print(original)

运行结果如下：
Vector2D(x: 4.0, y: 6.0)

等价运算符重载

• 自定义类和结构体不接收等价运算符的默认实现，也就是所谓的“等于”运算符（==）和不等于运算符（！=）。
• 要使用等价运算符来检查你自己类型的等价，需要和其他中缀运算符一样提供一个“等于”运算符重载，并且遵循标准库的 Equatable 协议

extension Vector2D: Equatable {
    static func ==(left: Vector2D, right: Vector2D) -> Bool {
        return (left.x == right.x) && (left.y == right.y)
    }
}

Swift 为以下自定义类型提供等价运算符合成实现：

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

struct Vector3D {
    var x = 0.0, y = 0.0, z = 0.0
}

extension Vector3D: Equatable {
    static func ==(left: Vector3D, right: Vector3D) -> Bool {
        return (left.x == right.x) && (left.y == right.y) && (left.z == right.z)
    }
}

let twoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
let anotherTwoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
if twoThreeFour == anotherTwoThreeFour {
    print("equal")
}

运行结果如下：
equal