코틀린 문법 - 연산자 함수 (operator fun)

🫧 연산자 함수 (operator fun)

kotlin에서 연산자 함수는 특정 연산자를 사용자 정의 타입에 대해 재정의 할 수 있게 하여 더 직관적이고 자연스러운 코드 작성을 가능하게 한다.
이를 통해 +, -, *, /, %, [] 등과 같은 연산자를 오버로딩할 수 있다.

✏️ 정의하기

연산자 함수를 정의하려면 operator 키워드를 사용하면 된다.

✏️ 예제

연산자 함수의 예로 + 연산자를 오버로딩 하는 방법을 살펴보자.
Point라는 데이터 클래스를 정의하고, + 연산자를 오버로딩하는 연산자 함수를 추가해보자.

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 result = p1 + p2
    println(result)  // 출력: Point(x=40, y=60)
}

여기서 operator fun plus는 + 연산자를 오버로딩하여 두 Point 객체를 더할 수 있게 한다.
result 변수는 p1과 p2의 합을 나타내는 새로운 Point 객체가 된다.

🫧 주요 연산자 함수

Kotlin에서 자주 사용되는 연산자 함수는 다음과 같다.

✏️ plus와 minus(+, -)

operator fun plus(other: T): T
operator fun minus(other: T): T

예시

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 result = p1 + p2
    println(result)  // 출력: Point(x=40, y=60)
}

data class Point(val x: Int, val y: Int) {
    operator fun minus(other: Point): Point {
        return Point(x - other.x, y - other.y)
    }
}

fun main() {
    val p1 = Point(30, 40)
    val p2 = Point(10, 20)
    val result = p1 - p2
    println(result)  // 출력: Point(x=20, y=20)
}

✏️ times, div, rem (*, /, %)

operator fun times(other: T): T
operator fun div(other: T): T
operator fun rem(other: T): T

예시

data class Point(val x: Int, val y: Int) {
    operator fun times(scale: Int): Point {
        return Point(x * scale, y * scale)
    }
}

fun main() {
    val p = Point(10, 20)
    val result = p * 2
    println(result)  // 출력: Point(x=20, y=40)
}

data class Point(val x: Int, val y: Int) {
    operator fun div(scale: Int): Point {
        return Point(x / scale, y / scale)
    }
}

fun main() {
    val p = Point(20, 40)
    val result = p / 2
    println(result)  // 출력: Point(x=10, y=20)
}

data class Point(val x: Int, val y: Int) {
    operator fun rem(modulus: Int): Point {
        return Point(x % modulus, y % modulus)
    }
}

fun main() {
    val p = Point(20, 45)
    val result = p % 6
    println(result)  // 출력: Point(x=2, y=3)
}

✏️ unaryPlus, unaryMinus, not (+, -, !)

operator fun unaryPlus(): T
operator fun unaryMinus(): T
operator fun not(): Boolean

예시

data class Point(val x: Int, val y: Int) {
    operator fun unaryPlus(): Point {
        return this
    }
}

fun main() {
    val p = Point(10, 20)
    val result = +p
    println(result)  // 출력: Point(x=10, y=20)
}

data class Point(val x: Int, val y: Int) {
    operator fun unaryMinus(): Point {
        return Point(-x, -y)
    }
}

fun main() {
    val p = Point(10, 20)
    val result = -p
    println(result)  // 출력: Point(x=-10, y=-20)
}

data class Toggle(val state: Boolean) {
    operator fun not(): Toggle {
        return Toggle(!state)
    }
}

fun main() {
    val toggle = Toggle(true)
    val result = !toggle
    println(result)  // 출력: Toggle(state=false)
}

✏️ get와 set ([])

operator fun get(index: Int): T
operator fun set(index: Int, value: T)

예시

class Matrix(private val data: Array<IntArray>) {
    operator fun get(i: Int, j: Int): Int {
        return data[i][j]
    }
}

fun main() {
    val matrix = Matrix(arrayOf(
        intArrayOf(1, 2, 3),
        intArrayOf(4, 5, 6),
        intArrayOf(7, 8, 9)
    ))

    println(matrix[1, 1])  // 출력: 5
}

class MutableMatrix(private val data: Array<IntArray>) {
    operator fun get(i: Int, j: Int): Int {
        return data[i][j]
    }

    operator fun set(i: Int, j: Int, value: Int) {
        data[i][j] = value
    }
}

fun main() {
    val matrix = MutableMatrix(arrayOf(
        intArrayOf(1, 2, 3),
        intArrayOf(4, 5, 6),
        intArrayOf(7, 8, 9)
    ))

    matrix[1, 1] = 42
    println(matrix[1, 1])  // 출력: 42
}

---

🫧 Reference

코틀린 공식 문서