Skip to main content

Sobrecarga de operadores

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

r8vnhill/object-oriented-programming-kt
Be lazy...

Puedes ejecutar el siguiente comando para crear el módulo 

./gradlew setupOperatorOverloadModule

Mientras se crean los archivos necesarios, puedes leer el código para saber qué está pasando.

import tasks.ModuleSetupTask

tasks.register<ModuleSetupTask>("setupOperatorOverloadModule") {
    description = "Creates the base module and files for the operator overloading lesson"
    module.set("operator-overload")
    doLast {
        createFiles(
            packageName = "math",
            test to "ComplexTest.kt",
            main to "Complex.kt",
        )
    }
}

Preocúpate de que el plugin operator-overload esté aplicado en el archivo build.gradle.kts de tu proyecto.

./gradlew setupOperatorOverloadModule

Preocúpate de que el nuevo módulo esté incluido en el archivo settings.gradle.kts.

A estas alturas, ya deberías conocer el concepto de sobrecarga de funciones (overloading). Como repaso rápido, la sobrecarga permite definir varias funciones con el mismo nombre, pero diferentes firmas (es decir, con distintos números o tipos de parámetros). Esto le permite a quien desarrolla reutilizar un mismo nombre para funciones que realizan tareas similares con diferentes tipos de datos.

De manera similar, la sobrecarga de operadores es una característica presente en lenguajes como Kotlin que permite definir comportamientos personalizados para operadores estándar como +, -, *, /, entre otros. Esto resulta especialmente útil cuando trabajamos con tipos de datos definidos por quien usa la biblioteca, ya que nos permite hacer que interactúen de forma más natural e intuitiva con los operadores existentes del lenguaje, facilitando su uso y mejorando la legibilidad del código.

Cómo Funciona la Sobrecarga de Operadores​

En Kotlin, para sobrecargar un operador, se declara una función utilizando la palabra clave operator antes de fun. El nombre de la función debe coincidir con uno de los nombres de las funciones de operador predefinidas, como plus, minus, times, entre otras.

Por ejemplo, la función plus se utiliza para sobrecargar el operador +. Esto permite que, cuando utilices el operador + con objetos de esa clase, Kotlin sepa qué operación ejecutar.

Ejemplo Práctico: Sobrecarga del Operador + para Números Complejos​

En este ejemplo, implementamos la sobrecarga del operador + en una clase Complex para sumar dos números complejos, así como sumar un número complejo con un valor Double.

Especificación BDD​

El siguiente esquema BDD describe el comportamiento esperado al sumar números complejos:

"Given a complex number" - {
    "when adding it to another complex number" - {
        "then the real part should be the sum of the real parts" {}
        "then the imaginary part should be the sum of the imaginary parts" {}
    }

    "when adding it to a real number" - {
        "then the real part should be the sum of the real part and the real number" {}
        "then the imaginary part should remain unchanged" {}
    }
}

Implementación de las pruebas​

Aquí tenemos las pruebas que verifican que la suma de números complejos y la suma con un número Double funcionan correctamente:

checkAll(arbComplex(), arbComplex()) { a, b ->
    val result = a + b
    result.real shouldBe (a.real + b.real)
}
checkAll(arbComplex(), Arb.double()) { a, b ->
    val result = a + b
    result.real shouldBe (a.real + b)
}

Implementación de la Clase Complex​

operator-overload/src/main/kotlin/com/github/username/complex/Complex.kt
package com.github.username.complex

class Complex(val real: Double, val imaginary: Double) {

    operator fun plus(other: Complex) =
        Complex(real + other.real, imaginary + other.imaginary)
}

operator fun Complex.plus(value: Double) = Complex(real + value, imaginary)

¿Qué acabamos de hacer?
  • Clase Complex: Almacena dos propiedades real (parte real) e imaginary (parte imaginaria).
  • Sobrecarga de plus para Complex: Definimos una función miembro plus que toma otro número complejo y devuelve un nuevo número complejo que es la suma de ambos.
  • Sobrecarga de plus para Double: Utilizamos una función de extensión para permitir la suma de un número complejo con un Double.
Uso Responsable de la Sobrecarga de Operadores

La sobrecarga de operadores es una herramienta poderosa que puede mejorar la legibilidad y expresividad de las APIs. Sin embargo, debe usarse con precaución, ya que un mal uso puede conducir a código confuso o engañoso, comprometiendo su claridad y coherencia.

Ejemplo de mal uso:

class Employee(val name: String, val salary: Double) {

    operator fun plus(other: Employee) =
        Employee("$name & ${other.name}", salary + other.salary)
}

fun main() {
    val emp1 = Employee("Alice", 5000.0)
    val emp2 = Employee("Bob", 4500.0)
    val combined = emp1 + emp2
    println("Empleado combinado: ${combined.name}, Salario total: ${combined.salary}")
    /* Output:
     Empleado combinado: Alice & Bob, Salario total: 9500.0
     */
}

En este caso, la sobrecarga del operador + combina nombres y suma salarios. Aunque técnicamente funciona, puede ser confuso para otras personas, ya que el operador + generalmente se asocia con una suma o concatenación simple, y no con la combinación de objetos de esta manera. Es mejor proporcionar métodos con nombres claros como combineWith para evitar ambigüedades.

Ejemplo práctico: Sobrecarga del operador invoke para invocación de funciones​

Además de los operadores aritméticos, Kotlin permite sobrecargar el operador invoke, lo que permite que los objetos se llamen como si fueran funciones. Esto es útil cuando queremos que un objeto se comporte como una función.

class Greeter(val greeting: String) {

    operator fun invoke(name: String)
        println("$greeting, $name!")
}
¿Qué acabamos de hacer?
  • Clase Greeter: Contiene un saludo predefinido.
  • Sobrecarga de invoke: Permite llamar a una instancia de Greeter pasando un nombre, como si fuera una función.

Uso:

fun main() {
    val greeter = Greeter("¡Hola")
    greeter("Carlos")  // Output: ¡Hola, Carlos!
}

Este enfoque hace que el código sea más conciso y natural, especialmente cuando el objeto representa una acción o comportamiento.

Beneficios y limitaciones de la sobrecarga de operadores​

Beneficios

  • Legibilidad y expresividad mejoradas: La sobrecarga de operadores permite que las operaciones en objetos personalizados se vean y se comporten de manera similar a los tipos primitivos, mejorando la legibilidad y expresividad del código.
  • Consistencia con operadores existentes: Facilita la integración de tipos definidos por el usuario en el lenguaje, permitiendo que interactúen de forma natural con operadores ya conocidos, lo que hace que las APIs sean más intuitivas y fáciles de usar.
  • Flexibilidad y personalización: Permite adaptar el comportamiento de los operadores para que se ajusten a las necesidades específicas de una clase o estructura de datos, ofreciendo una mayor flexibilidad en el diseño del código.
  • Implementación de patrones funcionales: El operador invoke permite tratar objetos como funciones, lo que es especialmente útil en programación funcional o cuando se busca crear DSLs (Domain-Specific Languages) en Kotlin.

Limitaciones

  • Ambigüedad y confusión: El uso indebido o excesivo de la sobrecarga de operadores puede hacer que el código sea confuso o difícil de entender para otras personas, especialmente si los operadores se utilizan para acciones no intuitivas.
  • Dificultad para mantener el código: Al personalizar operadores, es posible que personas que trabajen con nuestro código en el futuro no comprendan rápidamente qué está haciendo el código, lo que puede dificultar el mantenimiento y la extensión de las funcionalidades.
  • Inconsistencias con el comportamiento esperado: Cuando un operador se sobrecarga de una manera que se desvía de su uso habitual (como + para fusionar objetos en lugar de sumarlos), puede generar confusión y errores, ya que las expectativas sobre su funcionamiento no se cumplen.
  • Complejidad adicional: La implementación de sobrecargas de operadores introduce una capa adicional de abstracción, lo que puede aumentar la complejidad del código y hacer que el flujo de ejecución sea más difícil de rastrear, especialmente en proyectos grandes o colaborativos.

¿Qué aprendimos?​

En esta lección, exploramos la sobrecarga de operadores en Kotlin y cómo puede mejorar la expresividad y legibilidad del código al permitir el uso de operadores estándar en tipos de datos personalizados. Vimos cómo se implementa la sobrecarga usando la palabra clave operator y examinamos ejemplos prácticos, como la sobrecarga de + para números complejos e invoke para invocación de funciones.

Puntos clave​

  1. Flexibilidad y Expresividad: La sobrecarga de operadores permite crear APIs intuitivas y expresivas, haciendo que los tipos de datos personalizados se comporten de manera similar a los tipos nativos de Kotlin.
  2. Facilidad en la implementación de DSLs: Al sobrecargar operadores como invoke, es posible diseñar DSLs que proporcionan una sintaxis fluida y concisa.
  3. Uso responsable: Aunque poderosa, la sobrecarga de operadores debe utilizarse con cuidado para evitar confusión, ambigüedad y dificultades en el mantenimiento del código.

Al finalizar esta lección, es importante recordar que, si bien la sobrecarga de operadores puede enriquecer el diseño de un programa, debe usarse de manera consistente con las convenciones del lenguaje y las expectativas comunes para garantizar que el código sea claro, predecible y fácil de mantener.

C++
Python
Scala
Swift

Bibliografías Recomendadas

  • 📚 "7. Operator overloading and other conventions". (2017). Dmitry Jemerov, Svetlana Isakova, en Kotlin in action, (pp. 173–199.) Manning Publications Co.

Bibliografías Adicionales