运算符重载 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>此处返回 a ，如下所示：

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 在他们的回答中所建议的那样，添加一些构造函数而不是使用 a 的构造函数是可行的String，例如一个需要两个Ints，一个需要两个BigIntegerss .