操作符重载

// 定义一个表示二维点的数据类
data class Point(val x: Int, val y: Int) {
    
    // 使用 operator 关键字标记 plus 函数，表示这是 + 操作符的实现
    operator fun plus(other: Point): Point {
        // 返回两个点坐标相加的结果
        return Point(x + other.x, y + other.y)
    }
}
 
fun main() {
    val p1 = Point(10, 20)  // 创建第一个点 (10, 20)
    val p2 = Point(30, 40)  // 创建第二个点 (30, 40)
    
    // 使用 + 操作符，编译器会将其转换为 p1.plus(p2) 的函数调用
    val p3 = p1 + p2        // 结果为 Point(40, 60)
    
    println(p3)  // 输出: Point(x=40, y=60)
}

data class Point(val x: Int, val y: Int) {
    // 缺少 operator 关键字
    fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}
 
fun main() {
    val p1 = Point(10, 20)
    val p2 = Point(30, 40)
    val p3 = p1 + p2  // ❌ 编译错误: 'plus' must be marked with 'operator' modifier
}

// 定义一个表示复数的类 (Complex Number)
data class Complex(val real: Double, val imaginary: Double) {
    
    // 实现加法操作符：a + b → a.plus(b)
    operator fun plus(other: Complex): Complex {
        // 实部相加，虚部相加：(a+bi) + (c+di) = (a+c) + (b+d)i
        return Complex(real + other.real, imaginary + other.imaginary)
    }
    
    // 实现减法操作符：a - b → a.minus(b)
    operator fun minus(other: Complex): Complex {
        // 实部相减，虚部相减：(a+bi) - (c+di) = (a-c) + (b-d)i
        return Complex(real - other.real, imaginary - other.imaginary)
    }
    
    // 实现乘法操作符：a * b → a.times(b)
    operator fun times(other: Complex): Complex {
        // 复数乘法公式：(a+bi) * (c+di) = (ac-bd) + (ad+bc)i
        val newReal = real * other.real - imaginary * other.imaginary
        val newImaginary = real * other.imaginary + imaginary * other.real
        return Complex(newReal, newImaginary)
    }
    
    // 自定义输出格式
    override fun toString(): String {
        return when {
            imaginary >= 0 -> "$real + ${imaginary}i"  // 正虚部
            else -> "$real - ${-imaginary}i"           // 负虚部
        }
    }
}
 
fun main() {
    val c1 = Complex(3.0, 4.0)   // 3 + 4i
    val c2 = Complex(1.0, 2.0)   // 1 + 2i
    
    // 编译器将这些操作符表达式转换为函数调用
    val sum = c1 + c2           // 实际调用: c1.plus(c2)  → 4 + 6i
    val diff = c1 - c2          // 实际调用: c1.minus(c2) → 2 + 2i
    val product = c1 * c2       // 实际调用: c1.times(c2) → -5 + 10i
    
    println("和: $sum")          // 输出: 和: 4.0 + 6.0i
    println("差: $diff")         // 输出: 差: 2.0 + 2.0i
    println("积: $product")      // 输出: 积: -5.0 + 10.0i
}

// 为 String 类添加重复操作符：字符串 * 次数
operator fun String.times(n: Int): String {
    // 使用 repeat 函数重复字符串 n 次
    return this.repeat(n)
}
 
fun main() {
    val repeated = "Kotlin" * 3  // 调用扩展函数: "Kotlin".times(3)
    println(repeated)            // 输出: KotlinKotlinKotlin
}

// 定义一个表示向量的类
data class Vector2D(val x: Double, val y: Double) {
    
    // 实现一元加号：+a → a.unaryPlus()
    // 对于向量来说，一元加号通常返回自身（保持不变）
    operator fun unaryPlus(): Vector2D {
        return this  // 返回向量本身
    }
    
    // 实现一元减号：-a → a.unaryMinus()
    // 对于向量来说，一元减号返回反向量（方向相反）
    operator fun unaryMinus(): Vector2D {
        return Vector2D(-x, -y)  // x 和 y 分量都取反
    }
    
    override fun toString(): String = "($x, $y)"
}
 
fun main() {
    val v = Vector2D(3.0, 4.0)  // 创建向量 (3.0, 4.0)
    
    val positive = +v           // 调用 v.unaryPlus()，返回 (3.0, 4.0)
    val negative = -v           // 调用 v.unaryMinus()，返回 (-3.0, -4.0)
    
    println("原向量: $v")         // 输出: 原向量: (3.0, 4.0)
    println("+v: $positive")     // 输出: +v: (3.0, 4.0)
    println("-v: $negative")     // 输出: -v: (-3.0, -4.0)
    
    // 一元减号可以链式调用
    val doubleNegative = --v    // 相当于 -(-v)，调用两次 unaryMinus()
    println("--v: $doubleNegative")  // 输出: --v: (3.0, 4.0)
}

// 简化的大整数类（仅用于演示）
data class BigInt(val value: Long) {
    
    // 实现一元减号，取相反数
    operator fun unaryMinus(): BigInt {
        return BigInt(-value)  // 将内部值取反
    }
    
    // 实现加法以配合演示
    operator fun plus(other: BigInt): BigInt {
        return BigInt(value + other.value)
    }
}
 
fun main() {
    val a = BigInt(100)
    val b = BigInt(50)
    
    // 使用一元减号和加法构造复杂表达式
    val result = -a + b  // 相当于 (-100) + 50 = -50
    println(result.value)  // 输出: -50
}

// 定义一个表示开关状态的类
data class Switch(val isOn: Boolean) {
    
    // 实现逻辑非：!a → a.not()
    // 对于开关来说，逻辑非表示切换状态
    operator fun not(): Switch {
        return Switch(!isOn)  // 将 isOn 取反
    }
    
    override fun toString(): String = if (isOn) "ON" else "OFF"
}
 
fun main() {
    val switch = Switch(true)   // 创建一个开启的开关
    
    val toggled = !switch       // 调用 switch.not()，切换状态
    println("原状态: $switch")     // 输出: 原状态: ON
    println("切换后: $toggled")    // 输出: 切换后: OFF
    
    // 多次切换
    val toggledTwice = !!switch  // 两次取反，回到原始状态
    println("两次切换: $toggledTwice")  // 输出: 两次切换: ON
}

// 定义一个位掩码类，用于权限控制
@JvmInline  // 内联类，零开销抽象
value class Permission(val mask: Int) {
    
    // 实现逻辑非，表示取反所有权限位
    operator fun not(): Permission {
        return Permission(mask.inv())  // 使用 Int.inv() 进行按位取反
    }
    
    // 实现位或操作，用于组合权限
    operator fun or(other: Permission): Permission {
        return Permission(mask or other.mask)
    }
    
    // 实现位与操作，用于检查权限
    operator fun and(other: Permission): Permission {
        return Permission(mask and other.mask)
    }
    
    companion object {
        val READ = Permission(0b0001)    // 读权限: 0001
        val WRITE = Permission(0b0010)   // 写权限: 0010
        val EXECUTE = Permission(0b0100) // 执行权限: 0100
    }
}
 
fun main() {
    // 组合读写权限
    val readWrite = Permission.READ or Permission.WRITE  // 0011
    
    // 取反权限（假设使用 8 位表示）
    val denied = !readWrite  // 对 0011 取反
    
    println("读写权限: ${readWrite.mask.toString(2)}")  // 输出: 读写权限: 11
    println("拒绝权限: ${denied.mask.toString(2)}")     // 输出大量 1（取决于 Int 位数）
}

// 定义一个表示日期的简化类
data class SimpleDate(val year: Int, val month: Int, val day: Int) {
    
    // 实现自增：++a 或 a++ → a.inc()
    // 返回下一天的日期（简化版，不考虑月末和年末）
    operator fun inc(): SimpleDate {
        // 注意：返回新对象，不修改当前对象
        return when {
            day < 28 -> SimpleDate(year, month, day + 1)  // 日期 +1
            month < 12 -> SimpleDate(year, month + 1, 1)  // 下个月的第一天
            else -> SimpleDate(year + 1, 1, 1)            // 下一年的第一天
        }
    }
    
    // 实现自减：--a 或 a-- → a.dec()
    // 返回前一天的日期（简化版）
    operator fun dec(): SimpleDate {
        return when {
            day > 1 -> SimpleDate(year, month, day - 1)   // 日期 -1
            month > 1 -> SimpleDate(year, month - 1, 28)  // 上个月的最后一天（简化）
            else -> SimpleDate(year - 1, 12, 28)          // 上一年的最后一天（简化）
        }
    }
    
    override fun toString(): String = "$year-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')}"
}
 
fun main() {
    var date = SimpleDate(2024, 12, 31)  // 创建日期: 2024-12-31
    
    println("原日期: $date")              // 输出: 原日期: 2024-12-31
    
    // 前缀自增：先自增，再使用
    val nextDay = ++date                 // date 先变为 2025-01-01，然后赋值给 nextDay
    println("前缀++后: date=$date, nextDay=$nextDay")  
    // 输出: 前缀++后: date=2025-01-01, nextDay=2025-01-01
    
    // 后缀自增：先使用，再自增
    val currentDay = date++              // 先将 2025-01-01 赋值给 currentDay，date 再变为 2025-01-02
    println("后缀++后: date=$date, currentDay=$currentDay")
    // 输出: 后缀++后: date=2025-01-02, currentDay=2025-01-01
    
    // 自减操作
    --date  // date 变为 2025-01-01
    println("自减后: $date")              // 输出: 自减后: 2025-01-01
}

// 定义一个线程安全的计数器（简化版）
data class Counter(val count: Int) {
    
    // 实现自增
    operator fun inc(): Counter {
        return Counter(count + 1)  // 返回计数 +1 的新对象
    }
    
    // 实现自减
    operator fun dec(): Counter {
        return Counter(count - 1)  // 返回计数 -1 的新对象
    }
    
    // 实现比较操作符（用于循环条件）
    operator fun compareTo(other: Counter): Int {
        return count.compareTo(other.count)
    }
}
 
fun main() {
    var counter = Counter(0)  // 初始计数为 0
    
    // 使用自增操作符进行计数循环
    while (counter < Counter(5)) {
        println("当前计数: ${counter.count}")
        counter++  // 等价于 counter = counter.inc()
    }
    // 输出:
    // 当前计数: 0
    // 当前计数: 1
    // 当前计数: 2
    // 当前计数: 3
    // 当前计数: 4
    
    println("最终计数: ${counter.count}")  // 输出: 最终计数: 5
}

data class Score(val value: Int) {
    operator fun inc() = Score(value + 10)
    operator fun dec() = Score(value - 10)
}
 
fun main() {
    var score = Score(50)
    val temp1 = score++
    val temp2 = ++score
    println("${temp1.value}, ${temp2.value}, ${score.value}")
}

// 定义一个二维向量类，包含 x 和 y 两个坐标分量
data class Vector2D(val x: Double, val y: Double) {
    
    // 使用 operator 关键字标记 plus 函数，允许使用 + 操作符
    operator fun plus(other: Vector2D): Vector2D {
        // 将当前向量的 x 分量与 other 向量的 x 分量相加
        val newX = this.x + other.x
        // 将当前向量的 y 分量与 other 向量的 y 分量相加
        val newY = this.y + other.y
        // 返回一个新的 Vector2D 实例，体现不可变性原则
        return Vector2D(newX, newY)
    }
    
    // 重写 toString 方法以便于调试输出
    override fun toString(): String = "($x, $y)"
}
 
fun main() {
    // 创建两个向量实例
    val v1 = Vector2D(3.0, 4.0)  // 向量 v1 = (3, 4)
    val v2 = Vector2D(1.0, 2.0)  // 向量 v2 = (1, 2)
    
    // 使用 + 操作符，编译器会转换为 v1.plus(v2)
    val v3 = v1 + v2  // 结果：(4.0, 6.0)
    
    println("v1 + v2 = $v3")  // 输出: v1 + v2 = (4.0, 6.0)
    
    // 可以链式调用，因为返回类型也是 Vector2D
    val v4 = v1 + v2 + Vector2D(0.5, 0.5)
    println("链式加法: $v4")  // 输出: 链式加法: (4.5, 6.5)
}

// 定义复数类，包含实部(real)和虚部(imaginary)
data class Complex(val real: Double, val imaginary: Double) {
    
    // 加法：(a + bi) + (c + di) = (a+c) + (b+d)i
    operator fun plus(other: Complex): Complex {
        // 实部相加
        val newReal = this.real + other.real
        // 虚部相加
        val newImaginary = this.imaginary + other.imaginary
        return Complex(newReal, newImaginary)
    }
    
    // 减法：(a + bi) - (c + di) = (a-c) + (b-d)i
    operator fun minus(other: Complex): Complex {
        // 实部相减
        val newReal = this.real - other.real
        // 虚部相减
        val newImaginary = this.imaginary - other.imaginary
        return Complex(newReal, newImaginary)
    }
    
    // 乘法：(a + bi) * (c + di) = (ac - bd) + (ad + bc)i
    operator fun times(other: Complex): Complex {
        // 根据复数乘法公式计算实部：ac - bd
        val newReal = this.real * other.real - this.imaginary * other.imaginary
        // 根据复数乘法公式计算虚部：ad + bc
        val newImaginary = this.real * other.imaginary + this.imaginary * other.real
        return Complex(newReal, newImaginary)
    }
    
    // 除法：(a + bi) / (c + di) = [(a + bi)(c - di)] / (c² + d²)
    operator fun div(other: Complex): Complex {
        // 计算分母：c² + d²（模的平方）
        val denominator = other.real * other.real + other.imaginary * other.imaginary
        // 检查除数是否为零
        require(denominator != 0.0) { "不能除以零复数" }
        
        // 计算实部：(ac + bd) / (c² + d²)
        val newReal = (this.real * other.real + this.imaginary * other.imaginary) / denominator
        // 计算虚部：(bc - ad) / (c² + d²)
        val newImaginary = (this.imaginary * other.real - this.real * other.imaginary) / denominator
        return Complex(newReal, newImaginary)
    }
    
    // 取余运算（这里定义为模运算的一种变体）
    operator fun rem(other: Complex): Complex {
        // 注意：复数的模运算没有标准定义，这里仅作示例
        // 实际应用中需要根据具体需求定义语义
        val quotient = this / other  // 先计算商
        // 将商的实部和虚部都取整
        val flooredQuotient = Complex(
            kotlin.math.floor(quotient.real),
            kotlin.math.floor(quotient.imaginary)
        )
        // 余数 = 被除数 - 商 * 除数
        return this - (flooredQuotient * other)
    }
    
    // 重写 toString 以标准复数形式显示
    override fun toString(): String {
        return when {
            imaginary >= 0 -> "$real + ${imaginary}i"
            else -> "$real - ${-imaginary}i"
        }
    }
}
 
fun main() {
    val c1 = Complex(3.0, 4.0)   // 3 + 4i
    val c2 = Complex(1.0, 2.0)   // 1 + 2i
    
    // 测试加法
    println("加法: $c1 + $c2 = ${c1 + c2}")  // (4.0 + 6.0i)
    
    // 测试减法
    println("减法: $c1 - $c2 = ${c1 - c2}")  // (2.0 + 2.0i)
    
    // 测试乘法
    println("乘法: $c1 * $c2 = ${c1 * c2}")  // (-5.0 + 10.0i)
    
    // 测试除法
    println("除法: $c1 / $c2 = ${c1 / c2}")  // (2.2 + 0.4i)
    
    // 混合运算
    val result = (c1 + c2) * Complex(2.0, 0.0) / c2
    println("混合运算: $result")
}

data class Vector2D(val x: Double, val y: Double) {
    // 向量 * 标量（成员函数）
    operator fun times(scalar: Double): Vector2D {
        // 将向量的每个分量乘以标量
        return Vector2D(x * scalar, y * scalar)
    }
}
 
// 标量 * 向量（扩展函数，实现交换律）
// 注意：这里必须定义在类外部，因为接收者类型是 Double
operator fun Double.times(vector: Vector2D): Vector2D {
    // 调用向量的 times 函数，利用乘法交换律
    return vector * this
}
 
fun main() {
    val v = Vector2D(3.0, 4.0)
    
    // 向量在左，标量在右（使用成员函数）
    val v1 = v * 2.0  // 结果: (6.0, 8.0)
    
    // 标量在左，向量在右（使用扩展函数）
    val v2 = 2.0 * v  // 结果: (6.0, 8.0)
    
    println("v * 2.0 = $v1")
    println("2.0 * v = $v2")
    println("结果相等: ${v1 == v2}")  // true
}

// 定义点类，表示二维空间中的位置
data class Point(val x: Double, val y: Double)
 
// 定义向量类，表示方向和距离
data class Vector(val dx: Double, val dy: Double) {
    override fun toString() = "Vector(Δx=$dx, Δy=$dy)"
}
 
// 为 Point 类添加减法操作符，返回类型是 Vector
operator fun Point.minus(other: Point): Vector {
    // 计算 x 方向的位移
    val dx = this.x - other.x
    // 计算 y 方向的位移
    val dy = this.y - other.y
    // 返回向量而非点
    return Vector(dx, dy)
}
 
fun main() {
    val p1 = Point(5.0, 8.0)  // 起点
    val p2 = Point(2.0, 3.0)  // 终点
    
    // 两点相减得到向量
    val displacement: Vector = p1 - p2
    println("从 p2 到 p1 的位移: $displacement")  
    // 输出: 从 p2 到 p1 的位移: Vector(Δx=3.0, Δy=5.0)
}

class Matrix(private val data: Array<IntArray>) {
    // ❌ 错误示例：缺少 operator 关键字
    // fun plus(other: Matrix): Matrix { ... }
    
    // ✅ 正确示例
    operator fun plus(other: Matrix): Matrix {
        // 检查矩阵维度是否匹配
        require(data.size == other.data.size && 
                data[0].size == other.data[0].size) {
            "矩阵维度必须相同才能相加"
        }
        
        // 创建结果矩阵
        val result = Array(data.size) { i ->
            IntArray(data[0].size) { j ->
                // 对应元素相加
                data[i][j] + other.data[i][j]
            }
        }
        return Matrix(result)
    }
    
    // ❌ 错误示例：二元操作符不能有默认参数
    // operator fun times(scalar: Int = 1): Matrix { ... }
}

data class Counter(val value: Int) {
    // 仅定义 plus 操作符
    operator fun plus(other: Counter): Counter {
        // 返回新的 Counter 实例
        return Counter(this.value + other.value)
    }
}
 
fun main() {
    var c1 = Counter(10)  // 注意：必须是 var 才能重新赋值
    val c2 = Counter(5)
    
    // 编译器自动转换：c1 = c1 + c2
    c1 += c2  // 等价于 c1 = c1.plus(c2)
    
    println("c1.value = ${c1.value}")  // 输出: c1.value = 15
}

// 定义一个可变的整数累加器
class MutableCounter(private var value: Int) {
    
    // 显式定义 plusAssign，直接修改内部状态
    operator fun plusAssign(increment: Int) {
        // 注意：这里修改的是内部私有属性，不返回新对象
        value += increment  // 等价于 value = value + increment
    }
    
    // 提供 getter 以便外部读取
    fun getValue(): Int = value
    
    override fun toString() = "MutableCounter(value=$value)"
}
 
fun main() {
    val counter = MutableCounter(10)  // 可以用 val，因为不改变引用
    
    println("初始值: $counter")
    
    // 使用 += 操作符，调用 plusAssign
    counter += 5  // 直接修改内部状态
    println("加5后: $counter")  // 输出: MutableCounter(value=15)
    
    counter += 10
    println("再加10后: $counter")  // 输出: MutableCounter(value=25)
}

fun main() {
    // 创建可变列表
    val numbers = mutableListOf(1, 2, 3)
    
    // 使用 += 添加单个元素，调用 MutableList.plusAssign
    numbers += 4  // 等价于 numbers.plusAssign(4) 或 numbers.add(4)
    println("添加单个元素: $numbers")  // [1, 2, 3, 4]
    
    // 使用 += 添加多个元素，调用 MutableList.plusAssign(集合)
    numbers += listOf(5, 6, 7)  // 等价于 numbers.addAll(listOf(5, 6, 7))
    println("添加多个元素: $numbers")  // [1, 2, 3, 4, 5, 6, 7]
    
    // 使用 -= 删除元素，调用 MutableList.minusAssign
    numbers -= 3  // 等价于 numbers.remove(3)
    println("删除元素3: $numbers")  // [1, 2, 4, 5, 6, 7]
    
    // 创建可变集合（Set）
    val uniqueNumbers = mutableSetOf(1, 2, 3)
    uniqueNumbers += 4  // 自动去重
    uniqueNumbers += 2  // 重复元素不会添加
    println("可变集合: $uniqueNumbers")  // [1, 2, 3, 4]
}

// MutableList 的 plusAssign 扩展函数（标准库简化版）
operator fun <T> MutableCollection<T>.plusAssign(element: T) {
    // 直接调用集合的 add 方法
    this.add(element)
}
 
// 支持添加整个集合
operator fun <T> MutableCollection<T>.plusAssign(elements: Iterable<T>) {
    // 直接调用集合的 addAll 方法
    this.addAll(elements)
}
 
// MutableList 的 minusAssign 扩展函数
operator fun <T> MutableCollection<T>.minusAssign(element: T) {
    // 直接调用集合的 remove 方法
    this.remove(element)
}

class Ambiguous(val value: Int) {
    // 定义 plus，返回新对象
    operator fun plus(other: Ambiguous): Ambiguous {
        println("调用 plus")
        return Ambiguous(value + other.value)
    }
    
    // 同时定义 plusAssign，修改自身
    operator fun plusAssign(other: Ambiguous) {
        println("调用 plusAssign")
        // 注意：这里无法直接修改 value（因为它是 val）
        // 实际场景中应该使用 var 或修改内部可变状态
    }
}
 
fun main() {
    var a = Ambiguous(10)
    val b = Ambiguous(5)
    
    // ⚠️ 编译器警告或错误：存在二义性
    // 无法确定是调用 plusAssign 还是转换为 a = a + b
    // a += b  // 取消注释会导致编译错误
    
    // 解决方案1：显式调用
    a.plusAssign(b)  // 明确调用 plusAssign
    
    // 解决方案2：显式使用赋值形式
    a = a + b  // 明确使用 plus
}

// 定义一个可变的数学区间类
class MutableRange(
    private var start: Int,  // 起始值（可变）
    private var end: Int     // 结束值（可变）
) {
    // 扩展区间：将起始值减小，结束值增大
    operator fun plusAssign(expansion: Int) {
        require(expansion >= 0) { "扩展值必须非负" }
        // 向两端扩展
        start -= expansion
        end += expansion
    }
    
    // 收缩区间：将起始值增大，结束值减小
    operator fun minusAssign(contraction: Int) {
        require(contraction >= 0) { "收缩值必须非负" }
        // 向中心收缩
        start += contraction
        end -= contraction
        // 确保区间仍然有效
        require(start <= end) { "收缩后区间无效: [$start, $end]" }
    }
    
    // 放大区间：两端同时乘以倍数
    operator fun timesAssign(multiplier: Int) {
        require(multiplier > 0) { "倍数必须为正" }
        // 计算中心点
        val center = (start + end) / 2.0
        // 计算半径
        val halfWidth = (end - start) / 2.0
        // 放大半径
        val newHalfWidth = (halfWidth * multiplier).toInt()
        // 更新边界
        start = (center - newHalfWidth).toInt()
        end = (center + newHalfWidth).toInt()
    }
    
    // 检查某个值是否在区间内
    operator fun contains(value: Int): Boolean {
        return value in start..end
    }
    
    override fun toString() = "[$start, $end]"
}
 
fun main() {
    val range = MutableRange(10, 20)
    println("初始区间: $range")  // [10, 20]
    
    // 扩展区间
    range += 5
    println("扩展5单位后: $range")  // [5, 25]
    
    // 收缩区间
    range -= 3
    println("收缩3单位后: $range")  // [8, 22]
    
    // 放大区间
    range *= 2
    println("放大2倍后: $range")  // [1, 29]
    
    // 检查包含性
    println("15 是否在区间内: ${15 in range}")  // true
}

data class Box(val items: Int) {
    operator fun plus(other: Box) = Box(items + other.items)
    operator fun plusAssign(other: Box) {
        println("plusAssign被调用")
    }
}
 
fun main() {
    var box1 = Box(10)
    val box2 = Box(5)
    box1 += box2
    println(box1.items)
}

// 定义一个表示复数的类
class Complex(val real: Double, val imaginary: Double) {
    
    // 重写 equals 方法来定义相等性
    // 不需要 operator 关键字，因为这是重写而非新定义
    override fun equals(other: Any?): Boolean {
        // 检查是否是同一个引用
        if (this === other) return true
        
        // 检查类型是否匹配
        if (other !is Complex) return false
        
        // 比较实部和虚部
        return real == other.real && imaginary == other.imaginary
    }
    
    // 重写 equals 必须同时重写 hashCode，保持契约一致性
    override fun hashCode(): Int {
        var result = real.hashCode()
        result = 31 * result + imaginary.hashCode()
        return result
    }
    
    override fun toString() = "$real + ${imaginary}i"
}
 
fun main() {
    val c1 = Complex(3.0, 4.0)
    val c2 = Complex(3.0, 4.0)
    val c3 = c1
    
    // 结构相等：调用 equals() 方法
    println(c1 == c2)  // true，因为实部和虚部都相等
    
    // 引用相等：比较内存地址
    println(c1 === c2) // false，不同的对象实例
    println(c1 === c3) // true，指向同一个对象
    
    // != 操作符自动实现，等价于 !(c1 == c2)
    println(c1 != Complex(5.0, 6.0)) // true
}

// 定义一个表示版本号的类
class Version(val major: Int, val minor: Int, val patch: Int) : Comparable<Version> {
    
    // 实现 compareTo 方法，定义版本号的比较逻辑
    override operator fun compareTo(other: Version): Int {
        // 首先比较主版本号
        if (major != other.major) {
            return major - other.major
        }
        // 主版本号相同，比较次版本号
        if (minor != other.minor) {
            return minor - other.minor
        }
        // 次版本号也相同，比较修订号
        return patch - other.patch
    }
    
    override fun toString() = "$major.$minor.$patch"
}
 
fun main() {
    val v1 = Version(1, 2, 3)
    val v2 = Version(1, 2, 5)
    val v3 = Version(2, 0, 0)
    
    // 所有比较操作符都基于 compareTo 实现
    println(v1 < v2)   // true，因为 compareTo 返回负数
    println(v1 > v2)   // false
    println(v3 >= v1)  // true，主版本号更大
    println(v1 <= v2)  // true
    
    // 可以直接用于排序
    val versions = listOf(v3, v1, v2)
    println(versions.sorted()) // [1.2.3, 1.2.5, 2.0.0]
}

// 定义一个学生类，按照成绩、姓名排序
data class Student(val name: String, val score: Int, val age: Int) : Comparable<Student> {
    
    override fun compareTo(other: Student): Int {
        // 使用 compareValuesBy 实现多级比较
        // 首先按成绩降序，然后按姓名字典序，最后按年龄升序
        return compareValuesBy(
            this, other,
            { -it.score },     // 负号实现降序
            { it.name },       // 字典序
            { it.age }         // 升序
        )
    }
}
 
fun main() {
    val students = listOf(
        Student("Alice", 95, 20),
        Student("Bob", 95, 19),
        Student("Charlie", 90, 21)
    )
    
    // 自动按照 compareTo 定义的规则排序
    students.sorted().forEach { println(it) }
    // 输出:
    // Student(name=Alice, score=95, age=20)
    // Student(name=Bob, score=95, age=19)
    // Student(name=Charlie, score=90, age=21)
}

fun main() {
    val a: String? = "Hello"
    val b: String? = null
    
    // == 操作符会自动处理 null 情况
    // 等价于：a?.equals(b) ?: (b === null)
    println(a == b)     // false
    println(b == null)  // true
    println(null == null) // true
    
    // compareTo 不能直接用于可空类型
    val x: Int? = 5
    val y: Int? = 3
    
    // 错误：不能直接比较可空类型
    // println(x > y)  // 编译错误
    
    // 需要先进行空值检查
    if (x != null && y != null) {
        println(x > y)  // true
    }
}

// 定义一个表示金额的类，包含数值和货币单位
class Money(val amount: Double, val currency: String) : Comparable<Money> {
    
    // 重写 equals：只有金额和货币都相同才相等
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is Money) return false
        
        // 比较金额时使用 epsilon 避免浮点误差
        val epsilon = 0.001
        return kotlin.math.abs(amount - other.amount) < epsilon && 
               currency == other.currency
    }
    
    // 重写 hashCode 保持契约
    override fun hashCode(): Int {
        var result = amount.hashCode()
        result = 31 * result + currency.hashCode()
        return result
    }
    
    // 实现 compareTo：只能比较相同货币的金额
    override fun compareTo(other: Money): Int {
        // 检查货币是否相同
        require(currency == other.currency) {
            "无法比较不同货币: $currency vs ${other.currency}"
        }
        // 比较金额大小
        return amount.compareTo(other.amount)
    }
    
    override fun toString() = "$amount $currency"
}
 
fun main() {
    val price1 = Money(99.99, "USD")
    val price2 = Money(99.99, "USD")
    val price3 = Money(120.00, "USD")
    val price4 = Money(99.99, "CNY")
    
    // 相等性比较
    println(price1 == price2)  // true，金额和货币都相同
    println(price1 == price4)  // false，货币不同
    
    // 大小比较（相同货币）
    println(price1 < price3)   // true
    println(price3 >= price1)  // true
    
    // 尝试比较不同货币会抛出异常
    try {
        println(price1 > price4)
    } catch (e: IllegalArgumentException) {
        println("错误: ${e.message}")
        // 输出: 错误: 无法比较不同货币: USD vs CNY
    }
}

// 定义一个自定义的列表类
class CustomList<T>(private val elements: MutableList<T> = mutableListOf()) {
    
    // 重载 get 操作符，支持通过索引访问元素
    operator fun get(index: Int): T {
        // 检查索引是否有效
        require(index in elements.indices) {
            "索引越界: $index，有效范围: ${elements.indices}"
        }
        // 返回对应位置的元素
        return elements[index]
    }
    
    // 可以添加更多方法
    fun add(element: T) {
        elements.add(element)
    }
    
    val size: Int get() = elements.size
    
    override fun toString() = elements.toString()
}
 
fun main() {
    val list = CustomList<String>()
    list.add("Kotlin")
    list.add("Java")
    list.add("Python")
    
    // 使用索引访问操作符
    println(list[0])  // 调用 get(0)，输出: Kotlin
    println(list[1])  // 输出: Java
    
    // 索引越界会抛出异常
    try {
        println(list[10])
    } catch (e: IllegalArgumentException) {
        println("错误: ${e.message}")
    }
}

// 扩展上面的 CustomList 类，添加 set 操作符
class MutableCustomList<T>(private val elements: MutableList<T> = mutableListOf()) {
    
    // get 操作符：读取元素
    operator fun get(index: Int): T {
        require(index in elements.indices) {
            "索引越界: $index，有效范围: ${elements.indices}"
        }
        return elements[index]
    }
    
    // set 操作符：设置元素
    // 注意：set 必须返回 Unit
    operator fun set(index: Int, value: T) {
        require(index in elements.indices) {
            "索引越界: $index，有效范围: ${elements.indices}"
        }
        // 更新指定位置的元素
        elements[index] = value
    }
    
    fun add(element: T) {
        elements.add(element)
    }
    
    val size: Int get() = elements.size
    
    override fun toString() = elements.toString()
}
 
fun main() {
    val list = MutableCustomList<String>()
    list.add("Kotlin")
    list.add("Java")
    list.add("Python")
    
    println("修改前: $list")  // [Kotlin, Java, Python]
    
    // 使用索引赋值操作符
    list[1] = "Scala"  // 调用 set(1, "Scala")
    
    println("修改后: $list")  // [Kotlin, Scala, Python]
}

// 定义一个二维矩阵类
class Matrix(val rows: Int, val cols: Int) {
    // 使用一维数组存储二维数据
    private val data = DoubleArray(rows * cols)
    
    // 多参数 get 操作符：支持 matrix[row, col] 语法
    operator fun get(row: Int, col: Int): Double {
        // 检查行列索引是否有效
        require(row in 0 until rows && col in 0 until cols) {
            "索引越界: ($row, $col)，有效范围: (0..${rows-1}, 0..${cols-1})"
        }
        // 将二维索引转换为一维索引
        return data[row * cols + col]
    }
    
    // 多参数 set 操作符：支持 matrix[row, col] = value 语法
    operator fun set(row: Int, col: Int, value: Double) {
        require(row in 0 until rows && col in 0 until cols) {
            "索引越界: ($row, $col)，有效范围: (0..${rows-1}, 0..${cols-1})"
        }
        // 设置对应位置的值
        data[row * cols + col] = value
    }
    
    // 打印矩阵的辅助方法
    fun print() {
        for (i in 0 until rows) {
            for (j in 0 until cols) {
                print("${this[i, j]}\t")  // 使用 get 操作符
            }
            println()
        }
    }
}
 
fun main() {
    // 创建一个 3x3 矩阵
    val matrix = Matrix(3, 3)
    
    // 使用多维索引设置值
    matrix[0, 0] = 1.0
    matrix[0, 1] = 2.0
    matrix[0, 2] = 3.0
    matrix[1, 0] = 4.0
    matrix[1, 1] = 5.0
    matrix[1, 2] = 6.0
    matrix[2, 0] = 7.0
    matrix[2, 1] = 8.0
    matrix[2, 2] = 9.0
    
    // 读取和打印矩阵
    println("矩阵内容:")
    matrix.print()
    // 输出:
    // 1.0  2.0  3.0
    // 4.0  5.0  6.0
    // 7.0  8.0  9.0
    
    // 读取特定元素
    println("中心元素: ${matrix[1, 1]}")  // 5.0
}

// 定义一个稀疏矩阵类，只存储非零元素
class SparseMatrix(val rows: Int, val cols: Int) {
    // 使用 Map 存储非零元素，键为 (row, col) 的 Pair
    private val data = mutableMapOf<Pair<Int, Int>, Double>()
    
    // get 操作符：返回元素值，默认为 0.0
    operator fun get(row: Int, col: Int): Double {
        require(row in 0 until rows && col in 0 until cols) {
            "索引越界: ($row, $col)"
        }
        // 如果元素不存在于 Map 中，返回 0.0
        return data[Pair(row, col)] ?: 0.0
    }
    
    // set 操作符：只存储非零元素
    operator fun set(row: Int, col: Int, value: Double) {
        require(row in 0 until rows && col in 0 until cols) {
            "索引越界: ($row, $col)"
        }
        
        if (value != 0.0) {
            // 非零元素存入 Map
            data[Pair(row, col)] = value
        } else {
            // 零元素从 Map 中移除（如果存在）
            data.remove(Pair(row, col))
        }
    }
    
    // 获取非零元素的数量
    fun nonZeroCount() = data.size
    
    // 打印矩阵（展示稀疏特性）
    fun print() {
        for (i in 0 until rows) {
            for (j in 0 until cols) {
                val value = this[i, j]
                print(if (value == 0.0) "·\t" else "$value\t")
            }
            println()
        }
    }
}
 
fun main() {
    // 创建一个 5x5 的稀疏矩阵
    val sparse = SparseMatrix(5, 5)
    
    // 只设置少量非零元素
    sparse[0, 0] = 1.0
    sparse[2, 3] = 5.0
    sparse[4, 1] = 3.0
    
    println("稀疏矩阵 (· 表示零元素):")
    sparse.print()
    // 输出:
    // 1.0  ·    ·    ·    ·
    // ·    ·    ·    ·    ·
    // ·    ·    ·    5.0  ·
    // ·    ·    ·    ·    ·
    // ·    3.0  ·    ·    ·
    
    println("非零元素数量: ${sparse.nonZeroCount()}")  // 3
    println("总元素数量: ${sparse.rows * sparse.cols}")  // 25
}

// 为 String 添加安全的索引访问
operator fun String.get(range: IntRange): String {
    // 确保范围在有效区间内
    val safeRange = range.first.coerceAtLeast(0)..range.last.coerceAtMost(length - 1)
    return substring(safeRange)
}
 
// 为 Map 添加多键访问
operator fun <K, V> Map<K, V>.get(vararg keys: K): List<V?> {
    // 返回多个键对应的值列表
    return keys.map { this[it] }
}
 
fun main() {
    // 使用扩展的 String 索引访问
    val text = "Kotlin Programming"
    println(text[0..5])     // Kotlin
    println(text[7..100])   // Programming（自动限制范围）
    
    // 使用扩展的 Map 多键访问
    val scores = mapOf(
        "Alice" to 95,
        "Bob" to 87,
        "Charlie" to 92
    )
    
    val results = scores["Alice", "Charlie", "David"]
    println(results)  // [95, 92, null]
}

// 定义一个配置管理器类，支持链式索引访问
class Config(private val data: MutableMap<String, Any> = mutableMapOf()) {
    
    // get 操作符：支持键访问
    operator fun get(key: String): Any? {
        return data[key]
    }
    
    // set 操作符：支持键赋值
    operator fun set(key: String, value: Any) {
        data[key] = value
    }
    
    // 泛型的安全获取方法
    inline fun <reified T> getValue(key: String, default: T): T {
        val value = data[key]
        return when {
            value is T -> value
            else -> default
        }
    }
    
    // 支持嵌套配置
    fun getOrCreateSection(key: String): Config {
        val existing = data[key]
        if (existing is Config) {
            return existing
        }
        // 创建新的子配置
        val section = Config()
        data[key] = section
        return section
    }
    
    override fun toString(): String {
        return data.toString()
    }
}
 
fun main() {
    val config = Config()
    
    // 使用索引访问设置配置
    config["app.name"] = "MyApp"
    config["app.version"] = "1.0.0"
    config["server.port"] = 8080
    config["server.host"] = "localhost"
    
    // 读取配置
    println("应用名称: ${config["app.name"]}")  // MyApp
    println("端口: ${config["server.port"]}")   // 8080
    
    // 使用类型安全的方法
    val port = config.getValue("server.port", 3000)
    val timeout = config.getValue("server.timeout", 30) // 使用默认值
    
    println("端口(Int): $port")      // 8080
    println("超时(Int): $timeout")   // 30
    
    // 嵌套配置
    val dbConfig = config.getOrCreateSection("database")
    dbConfig["host"] = "db.example.com"
    dbConfig["port"] = 5432
    
    println("完整配置: $config")
}

class Point(val x: Int, val y: Int) : Comparable<Point> {
    override fun compareTo(other: Point): Int {
        return when {
            x != other.x -> x - other.x
            else -> y - other.y
        }
    }
}
 
fun main() {
    val p1 = Point(3, 5)
    val p2 = Point(3, 2)
    val p3 = Point(1, 8)
    println(p1 > p2)
    println(p2 > p3)
}

class Grid<T>(private val width: Int, private val height: Int) {
    private val data = MutableList<T?>(width * height) { null }
    
    operator fun get(x: Int, y: Int): T? = data[y * width + x]
    operator fun set(x: Int, y: Int, value: T) {
        data[y * width + x] = value
    }
}
 
fun main() {
    val grid = Grid<String>(3, 2)
    grid[1, 0] = "A"
    grid[2, 1] = "B"
    println(grid[1, 0])
    println(grid[0, 0])
}

// 自定义一个简单的集合类
class SimpleSet<T>(private val items: MutableList<T> = mutableListOf()) {
    
    // 定义 contains 操作符函数，使其支持 in 检查
    operator fun contains(element: T): Boolean {
        // 遍历内部列表，检查元素是否存在
        for (item in items) {
            if (item == element) {
                return true  // 找到元素，返回 true
            }
        }
        return false  // 未找到元素，返回 false
    }
    
    // 添加元素的辅助方法
    fun add(element: T) {
        items.add(element)
    }
}
 
fun main() {
    val mySet = SimpleSet<String>()
    mySet.add("Kotlin")
    mySet.add("Java")
    mySet.add("Python")
    
    // 使用 in 操作符检查成员资格
    println("Kotlin" in mySet)      // 输出: true (调用 mySet.contains("Kotlin"))
    println("Swift" in mySet)       // 输出: false
    println("Java" !in mySet)       // 输出: false (!in 是 in 的否定形式)
}

fun checkAge(age: Int) {
    // 使用 in 检查年龄是否在合法范围内
    when {
        age in 0..17 -> {
            // age 是否在 [0, 17] 闭区间内
            println("未成年人: $age 岁")
        }
        age in 18..65 -> {
            // age 是否在 [18, 65] 闭区间内
            println("成年人: $age 岁")
        }
        age in 66..120 -> {
            // age 是否在 [66, 120] 闭区间内
            println("老年人: $age 岁")
        }
        else -> {
            println("无效年龄: $age")
        }
    }
}
 
fun main() {
    checkAge(15)   // 输出: 未成年人: 15 岁
    checkAge(30)   // 输出: 成年人: 30 岁
    checkAge(70)   // 输出: 老年人: 70 岁
    
    // in 也可以用于字符范围
    val char = 'm'
    if (char in 'a'..'z') {
        println("$char 是小写字母")  // 输出: m 是小写字母
    }
    
    // 检查浮点数范围
    val score = 85.5
    if (score in 60.0..100.0) {
        println("及格分数: $score")  // 输出: 及格分数: 85.5
    }
}

fun validateInput(value: Int): Boolean {
    // 检查值是否在多个有效范围内的任意一个
    return value in 1..10 || value in 20..30 || value in 40..50
}
 
fun isWeekend(dayOfWeek: Int): Boolean {
    // 检查是否为周末 (假设 6=周六, 7=周日)
    return dayOfWeek in 6..7
}
 
fun main() {
    println(validateInput(5))    // 输出: true (在 1..10 范围内)
    println(validateInput(15))   // 输出: false (不在任何有效范围内)
    println(validateInput(25))   // 输出: true (在 20..30 范围内)
    
    println(isWeekend(6))        // 输出: true
    println(isWeekend(3))        // 输出: false
}

// 定义一个表示日期范围的类
data class DateRange(val start: Int, val end: Int) {
    
    // 实现 contains 操作符，检查某个日期是否在范围内
    operator fun contains(date: Int): Boolean {
        // 检查日期是否在 start 和 end 之间（包含边界）
        return date in start..end
    }
}
 
// 定义一个表示二维坐标点的类
data class Point(val x: Int, val y: Int)
 
// 定义一个表示矩形区域的类
data class Rectangle(val topLeft: Point, val bottomRight: Point) {
    
    // 实现 contains 操作符，检查某个点是否在矩形内
    operator fun contains(point: Point): Boolean {
        // 检查点的 x 坐标是否在矩形的水平范围内
        val inXRange = point.x in topLeft.x..bottomRight.x
        // 检查点的 y 坐标是否在矩形的垂直范围内
        val inYRange = point.y in topLeft.y..bottomRight.y
        // 只有当点同时在水平和垂直范围内时，才认为点在矩形内
        return inXRange && inYRange
    }
}
 
fun main() {
    // 日期范围检查
    val summerVacation = DateRange(start = 601, end = 831)  // 6月1日到8月31日
    println(715 in summerVacation)    // 输出: true (7月15日在暑假范围内)
    println(1001 in summerVacation)   // 输出: false (10月1日不在暑假范围内)
    
    // 矩形区域检查
    val screen = Rectangle(
        topLeft = Point(0, 0),
        bottomRight = Point(1920, 1080)
    )
    
    val clickPoint1 = Point(100, 200)
    val clickPoint2 = Point(2000, 500)
    
    println(clickPoint1 in screen)    // 输出: true (点在屏幕范围内)
    println(clickPoint2 in screen)    // 输出: false (点超出屏幕范围)
}

fun main() {
    // List 的 in 检查
    val languages = listOf("Kotlin", "Java", "Python", "JavaScript")
    println("Kotlin" in languages)        // 输出: true
    println("Swift" in languages)         // 输出: false
    
    // Set 的 in 检查 (性能通常优于 List)
    val primeNumbers = setOf(2, 3, 5, 7, 11, 13, 17, 19)
    println(7 in primeNumbers)            // 输出: true (O(1) 时间复杂度)
    println(10 in primeNumbers)           // 输出: false
    
    // Map 的 in 检查 (检查键是否存在)
    val capitals = mapOf(
        "中国" to "北京",
        "美国" to "华盛顿",
        "日本" to "东京"
    )
    println("中国" in capitals)           // 输出: true (检查键)
    println("北京" in capitals)           // 输出: false (这是值，不是键)
    println("英国" in capitals)           // 输出: false
    
    // 如果要检查值是否存在，需要使用 containsValue
    println(capitals.containsValue("北京"))  // 输出: true
    
    // String 也支持 in 检查 (检查子串)
    val message = "Hello, Kotlin!"
    println("Kotlin" in message)          // 输出: true
    println("Java" in message)            // 输出: false
}