Swift 中的运算符重载与自定义操作符

概述

在 Swift 中，我们可以为自定义的数据类型或已有的数据类型进行运算符重载，从而符合我们自己的需求。运算符重载可以使我们的代码更加简洁、易读，并提高代码的可重用性。

运算符重载

运算符重载是指对已有的运算符进行重新定义，使其能够适用于我们自定义的类型。通过运算符重载，我们可以对操作符进行不同的处理逻辑，从而实现不同的功能。

语法

运算符重载的语法如下所示：

func +(lhs: T, rhs: T) -> T {
    // 处理逻辑
    return result
}

其中，+ 是被重载的运算符，lhs 和 rhs 分别是该运算符作用的两个操作数，T 表示自定义的类型。在函数体中，我们可以根据需要实现不同的逻辑操作，并返回结果。

示例

例如，我们可以为 Vec2D 结构体定义一个 + 运算符的重载方法，使其实现两个坐标相加的功能：

struct Vec2D {
    var x: Int
    var y: Int
}

func +(lhs: Vec2D, rhs: Vec2D) -> Vec2D {
    return Vec2D(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
}

let vec1 = Vec2D(x: 1, y: 2)
let vec2 = Vec2D(x: 3, y: 4)
let vec3 = vec1 + vec2
print(vec3) // 输出: Vec2D(x: 4, y: 6)

自定义操作符

除了对已有的运算符进行重载，Swift 还提供了自定义操作符的能力。自定义操作符可以使我们的代码更加简洁、易读，并且能够根据需求定义新的操作符。

语法

自定义操作符的语法如下所示：

prefix | infix | postfix operator `操作符名称`

其中，prefix 表示前缀操作符，如 +、-，infix 表示中缀操作符，如 +、-、*，postfix 表示后缀操作符，如 !。

示例

例如，我们可以为自定义的类型 Matrix 定义一个中缀操作符 ^^，实现矩阵的乘法操作：

struct Matrix {
    let rows: Int
    let columns: Int
    var grid: [Double]
    
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        self.grid = Array(repeating: 0.0, count: rows * columns)
    }
    
    subscript(row: Int, column: Int) -> Double {
        get {
            return grid[(row * columns) + column]
        }
        set {
            grid[(row * columns) + column] = newValue
        }
    }
}

infix operator ^^

func ^^(lhs: Matrix, rhs: Matrix) -> Matrix {
    assert(lhs.columns == rhs.rows, "矩阵的列数不等于右边矩阵的行数")
    
    var result = Matrix(rows: lhs.rows, columns: rhs.columns)
    
    for i in 0..<lhs.rows {
        for j in 0..<rhs.columns {
            var sum = 0.0
            for k in 0..<lhs.columns {
                sum += lhs[i, k] * rhs[k, j]
            }
            result[i, j] = sum
        }
    }
    
    return result
}

let matrix1 = Matrix(rows: 2, columns: 3)
matrix1[0, 0] = 1
matrix1[0, 1] = 2
matrix1[0, 2] = 3
matrix1[1, 0] = 4
matrix1[1, 1] = 5
matrix1[1, 2] = 6

let matrix2 = Matrix(rows: 3, columns: 2)
matrix2[0, 0] = 1
matrix2[0, 1] = 2
matrix2[1, 0] = 3
matrix2[1, 1] = 4
matrix2[2, 0] = 5
matrix2[2, 1] = 6

let matrix3 = matrix1 ^^ matrix2
print(matrix3.grid) // 输出: [22.0, 28.0, 49.0, 64.0]

总结

在 Swift 中，通过运算符重载和自定义操作符，我们可以根据自己的需求定义出适用于自定义类型的运算符。运算符重载可以使我们的代码更加简洁、易读，并提高代码的可重用性；自定义操作符能够根据需求定义新的操作符，使代码更加语义化。合理运用运算符重载和自定义操作符，可以使我们的代码更加优雅、简洁，提高编程效率。