运算符重载 Kotlin

Question

我是 kotlin 的新手，我正在为我定义的自定义类处理运算符重载。该类称为“有理数”，表示有理数，例如 117/1098。类定义如下，我重载了一堆运算符，如加号、减号、时间等。但是我不确定我必须做些什么来重载“in”运算符。

这是我的课：

data class Rational(val rational: String) {
    private val numerator: BigInteger
    private val denominator: BigInteger

    init {
        val splitted = rational.split("/")
        numerator = splitted[0].toBigInteger()
        denominator = when (splitted[1]) {
            "0" -> throw Exception("not allowed")
            else -> splitted[1].toBigInteger()
        }
    }

    operator fun plus(number: Rational): Rational {
        val gcm = denominator * number.denominator
        val numerator = (gcm / denominator) * numerator + (gcm / number.denominator) * number.numerator
        return Rational("$numerator/$gcm")
    }

    operator fun minus(number: Rational): Rational {
        val gcm = denominator * number.denominator
        val numerator = (gcm / denominator) * numerator - (gcm / number.denominator) * number.numerator
        return Rational("$numerator/$gcm")
    }

    operator fun times(number: Rational): Rational {
        val numerator = numerator * number.numerator
        val denominator = denominator * number.denominator
        return Rational("$numerator/$denominator")
    }

    operator fun div(number: Rational): Rational {
        val numerator = numerator * number.denominator
        val denominator = denominator * number.numerator
        return Rational("$numerator/$denominator")
    }

    operator fun compareTo(number: Rational): Int {
        val ratio = this.numerator.toFloat() / this.denominator.toFloat()
        val numberRatio = number.numerator.toFloat() / number.denominator.toFloat()
        if (ratio > numberRatio) {
            return 1
        } else if (ratio == numberRatio) {
            return 0
        }
        return -1
    }

    operator fun unaryMinus(): Rational {
        val inverseNumerator = -numerator
        return Rational("$inverseNumerator/$denominator")
    }

    operator fun unaryPlus(): Rational {
        return Rational("$numerator/$denominator")
    }

    operator fun rangeTo(end: Rational): Any {
        var range: MutableList<Rational> = arrayListOf()
        val startNumerator = this.numerator.toInt()
        val endNumerator = end.numerator.toInt()
        var index = 0
        if (this.denominator == end.denominator) {
            for (i in startNumerator..endNumerator) {
                range.add(index, Rational("$i/$denominator"))
            }
        }
        return range
    }

    operator fun contains(number: Rational): Boolean {
        if (this.denominator % number.denominator == 0.toBigInteger()
                && this.numerator <= number.numerator) {
            return true
        }
        return false
    }

    override fun toString(): String {
        val gcd = numerator.gcd(denominator)
        return if (gcd != null) {
            val newNumerator = numerator / gcd
            val newDenominator = denominator / gcd
            "$newNumerator/$newDenominator"
        } else {
            "$numerator/$denominator"
        }
    }
}

infix fun Int.divBy(denominator: Int): Rational {
    if (denominator == 0) {
        throw Exception("denominator 0 not allowed")
    }

    return Rational("$this/$denominator")
}

infix fun Long.divBy(denominator: Long): Rational {
    if (denominator == 0L) {
        throw Exception("denominator 0 not allowed")
    }
    return Rational("$this/$denominator")
}

infix fun BigInteger.divBy(denominator: BigInteger): Rational {
    if (denominator == 0.toBigInteger()) {
        throw Exception("denominator 0 not allowed")
    }
    return Rational("$this/$denominator")
}

fun String.toRational(): Rational {
    return Rational(this)
}

这是我的主体，显然仍然无法编译：

fun main() {
    val half = 1 divBy 2
    val third = 1 divBy 3
    val twoThirds = 2 divBy 3

    println(half in third..twoThirds) // this line does not compile beacause in operator is not defined for the class
}

我想我必须重写“rangeTo”运算符，但我不确定运算符原型。我有人可以请帮助我走上正轨吗？

Answer 1

使in 工作的方法是让third..twoThirds 调用返回具有contains(Rational) 方法的一些东西，这就是in 调用所转换的内容。

一种方法是在此处返回ClosedRange<Rational>，如下所示：

operator fun rangeTo(end: Rational): ClosedRange<Rational> {
    return object : ClosedRange<Rational> {
        override val endInclusive: Rational = end
        override val start: Rational = this@Rational
    }
}

这对Rational 施加了类型约束，因为ClosedRange 需要Comparable 实现才能确定一个值是否属于其中。您可以通过实现Comparable 接口，然后将operator 添加到您现有的compareTo 运算符来做到这一点（另外，重命名参数以匹配接口是一个很好的做法）：

data class Rational(val rational: String) : Comparable<Rational> {

    ...

    override operator fun compareTo(other: Rational): Int {
        val ratio = this.numerator.toFloat() / this.denominator.toFloat()
        val numberRatio = other.numerator.toFloat() / other.denominator.toFloat()
        if (ratio > numberRatio) {
            return 1
        } else if (ratio == numberRatio) {
            return 0
        }
        return -1
    }

}

您还可以通过使用此实现来完全避免转换为浮点数，正如@gidds 在下面的评论中所建议的那样：

override operator fun compareTo(other: Rational): Int {
    return (numerator * other.denominator - denominator * other.numerator).signum()
}

此外，您当前的 contains 实现可能可能被丢弃，因为您不再需要它，而且它的功能相当奇怪。

---

要在此处添加直接答案以外的其他内容：正如@Eugene Petrenko 在他们的回答中建议的那样，添加几个构造函数而不是使用String 的构造函数是实际的，例如一个需要两个@987654340 的构造函数@s，一个需要两个BigIntegerss。

Answer 2

in 运算符被声明为逆运算符。您需要在右侧使用左侧的扩展功能。

https://kotlinlang.org/docs/reference/operator-overloading.html#in

您错过了一个中缀函数 divBy 以允许将 Int 转换为 Rational，例如

infix fun Int.divBy(i: Int) = Rational("$this/$i")

val half = 1 divBy 2 这样的代码不会起作用。从理论上讲，从Ints 为Rational 添加构造函数以避免解析可能是有意义的。

Rational 类中的rangeTo 方法的返回类型不正确，它不应该是Any。它应该被声明为

data class RationalRange(val left: Rational, val right: Rational) {
  operator fun contains(r: Rational) = left <= r && r <= right
}

operator fun rangeTo(end: Rational): RationalRange(this, end) 

现在x in a..b 的例子应该可以工作了。

UPD：添加了 RationalRange。我错过了重点，对不起。您根本不需要为Rational 类实现contains 函数。

Rational 的 compareTo 函数不太可能使用 .toFloat() 代替，您可以直接用整数实现它

Answer 3

一个简单的解决方案是在您的类中实现 Comparable 接口。

data class Rational(val rational: String) : Comparable<Rational>

然后使用您的比较逻辑实现 compareTo() 函数。

override fun compareTo(other: Rational): Int {
    //Normalize the numerators of each rational
    val thisNumerator = this.numerator * other.denominator
    val otherNumerator = other.numerator * this.denominator
    //Then compare them
    return when{
        thisNumerator > otherNumerator -> 1
        thisNumerator < otherNumerator -> -1
        else -> 0
    }
}

这将解决编译错误，而无需使用自定义逻辑覆盖 rangeTo() 函数。