5.7.6 运算符重载

原文链接: https://kotlinlang.org/docs/operator-overloading.html

5.7.6 运算符重载

Kotlin 允许你为类型上预定义的一组运算符提供自定义实现。这些运算符有预定义的符号表示（例如 + 或 *）和优先级。要实现某个运算符，请为相应类型提供一个具有特定名称的成员函数或扩展函数。该类型会成为二元运算的左侧类型，以及一元运算的参数类型。

要重载运算符，请用 operator 修饰符标记相应的函数：

1
2
3

interface IndexedContainer {
    operator fun get(index: Int)
}

在重写你的运算符重载时，可以省略 operator：

1
2
3

class OrdersList: IndexedContainer {
    override fun get(index: Int) { /*...*/ }
}

一元运算

一元前缀运算符

| 表达式 | 转换结果 |

| +a | a.unaryPlus() | | -a | a.unaryMinus() | | !a | a.not() |

这张表说明，当编译器处理例如表达式 +a 时，会执行以下步骤：

• 确定 a 的类型，记为 T。
• 为接收者 T 查找带 operator 修饰符且没有参数的函数 unaryPlus()，即成员函数或扩展函数。
• 如果该函数不存在或有歧义，就是编译错误。
• 如果该函数存在且返回类型为 R，则表达式 +a 的类型为 R。

注意： 这些运算以及其他所有运算都对基本类型做了优化，不会为它们引入函数调用开销。

举个例子，下面演示如何重载一元减号运算符：

1
2
3
4
5
6
7
8
9

data class Point(val x: Int, val y: Int)

operator fun Point.unaryMinus() = Point(-x, -y)

val point = Point(10, 20)

fun main() {
   println(-point) // 打印 "Point(x=-10, y=-20)"
}

自增与自减

| 表达式 | 转换结果 |

| a++ | a.inc() + 见下文 | | a-- | a.dec() + 见下文 |

inc() 和 dec() 函数必须返回一个值，该值会被赋给使用 ++ 或 -- 运算的变量。它们不应当修改调用 inc 或 dec 的那个对象。

对于后缀形式的运算符（例如 a++），编译器按以下步骤解析：

• 确定 a 的类型，记为 T。
• 查找带 operator 修饰符且没有参数、适用于类型 T 接收者的函数 inc()。
• 检查该函数的返回类型是 T 的子类型。

计算该表达式的效果是：

• 把 a 的初始值存入临时存储 a0。
• 把 a0.inc() 的结果赋给 a。
• 返回 a0 作为表达式的结果。

对于 a--，步骤完全类似。

对于前缀形式 ++a 和 --a，解析方式相同，其效果是：

• 把 a.inc() 的结果赋给 a。
• 返回 a 的新值作为表达式的结果。

二元运算

算术运算符

| 表达式 | 转换结果 |

| a + b | a.plus(b) | | a - b | a.minus(b) | | a * b | a.times(b) | | a / b | a.div(b) | | a % b | a.rem(b) | | a..b | a.rangeTo(b) | | a..<b | a.rangeUntil(b) |

对于表中的这些运算，编译器只是按"转换结果"列来解析表达式。

下面是一个 Counter 类的例子，它从给定值开始，并可以用重载的 + 运算符递增：

1
2
3
4
5

data class Counter(val dayIndex: Int) {
    operator fun plus(increment: Int): Counter {
        return Counter(dayIndex + increment)
    }
}

in 运算符

| 表达式 | 转换结果 |

| a in b | b.contains(a) | | a !in b | !b.contains(a) |

对于 in 和 !in，过程相同，只是参数顺序相反。

索引访问运算符

| 表达式 | 转换结果 |

| a[i] | a.get(i) | | a[i, j] | a.get(i, j) | | a[i_1, ..., i_n] | a.get(i_1, ..., i_n) | | a[i] = b | a.set(i, b) | | a[i, j] = b | a.set(i, j, b) | | a[i_1, ..., i_n] = b | a.set(i_1, ..., i_n, b) |

方括号会被转换为对 get 和 set 的调用，并带有相应数量的参数。

invoke 运算符

| 表达式 | 转换结果 |

| a() | a.invoke() | | a(i) | a.invoke(i) | | a(i, j) | a.invoke(i, j) | | a(i_1, ..., i_n) | a.invoke(i_1, ..., i_n) |

圆括号会被转换为对 invoke 的调用，并带有相应数量的参数。

复合赋值

| 表达式 | 转换结果 |

| a += b | a.plusAssign(b) | | a -= b | a.minusAssign(b) | | a *= b | a.timesAssign(b) | | a /= b | a.divAssign(b) | | a %= b | a.remAssign(b) |

对于赋值运算（例如 a += b），编译器执行以下步骤：

• 如果右列中的函数可用：
• 如果对应的二元函数（即 plusAssign() 对应的 plus()）也可用，a 是可变变量，并且 plus 的返回类型是 a 的类型的子类型，则报错（歧义）。
• 确保其返回类型为 Unit，否则报错。
• 为 a.plusAssign(b) 生成代码。
• 否则，尝试为 a = a + b 生成代码（这包含类型检查：a + b 的类型必须是 a 的子类型）。

注意： 在 Kotlin 中，赋值不是表达式。

相等与不等运算符

| 表达式 | 转换结果 |

| a == b | a?.equals(b) ?: (b === null) | | a != b | !(a?.equals(b) ?: (b === null)) |

这些运算符只与函数 equals(other: Any?): Boolean 配合使用，你可以重写它来提供自定义的相等性检查实现。任何同名的其他函数（例如 equals(other: Foo)）都会被忽略。

当 == 表达式中两个操作数都不直接与 null 比较、并且比较不是在两个浮点类型之间进行时，Kotlin 会调用 .equals()。否则，Kotlin 会对直接的 null 比较使用 ===，并按数值比较非空的浮点值。

注意： === 和 !==（同一性检查）不可重载，因此它们没有约定。

比较运算符

| 表达式 | 转换结果 |

| a > b | a.compareTo(b) > 0 | | a < b | a.compareTo(b) < 0 | | a >= b | a.compareTo(b) >= 0 | | a <= b | a.compareTo(b) <= 0 |

所有比较都会被转换为对 compareTo 的调用，它必须返回 Int。

属性委托运算符

provideDelegate、getValue 和 setValue 运算符函数在委托属性中介绍。

具名函数的中缀调用

你可以使用中缀函数调用来模拟自定义的中缀运算。