En programación informática , la sobrecarga de operadores , a veces denominada polimorfismo ad hoc de operadores , es un caso específico de polimorfismo , en el que distintos operadores tienen distintas implementaciones según sus argumentos. La sobrecarga de operadores suele definirse por un lenguaje de programación , un programador o ambos.
La sobrecarga de operadores es un azúcar sintáctico y se utiliza porque permite programar utilizando una notación más cercana al dominio de destino [1] y permite que los tipos definidos por el usuario tengan un nivel de soporte sintáctico similar al de los tipos integrados en un lenguaje. Es común, por ejemplo, en la computación científica, donde permite manipular representaciones computacionales de objetos matemáticos con la misma sintaxis que en el papel.
La sobrecarga de operadores no altera el poder expresivo de un lenguaje (con funciones), ya que se puede emular mediante llamadas a funciones. Por ejemplo, considere variables y ade algún tipo definido por el usuario, como matrices :bc
a + b * c
En un lenguaje que admite la sobrecarga de operadores, y con el supuesto habitual de que el operador '*' tiene mayor precedencia que el operador '+', esta es una forma concisa de escribir:
Add(a, Multiply(b, c))
Sin embargo, la sintaxis anterior refleja un uso matemático común.
En este caso, el operador de suma se sobrecarga para permitir la suma en un tipo definido por el usuario Timeen C++ :
Operador de tiempo + ( const Tiempo & lhs , const Tiempo & rhs ) { Tiempo temp = lhs ; temp . segundos += rhs . segundos ; temp . minutos += temp . segundos / 60 ; temp . segundos %= 60 ; temp . minutos += rhs . minutos ; temp . horas += temp . minutos / 60 ; temp . minutos %= 60 ; temp . horas += rhs . horas ; devolver temp ; } La suma es una operación binaria , lo que significa que tiene dos operandos . En C++, los argumentos que se pasan son los operandos y el tempobjeto es el valor devuelto.
La operación también podría definirse como un método de clase, reemplazándola lhspor el thisargumento oculto; sin embargo, esto obliga a que el operando izquierdo sea del tipo Time:
// La "const" justo antes de la llave de apertura significa que |this| no se modifica. Time Time :: operator + ( const Time & rhs ) const { Time temp = * this ; // |this| no debe modificarse, por lo que debe hacer una copia. temp . seconds += rhs . seconds ; temp . minutes += temp . seconds / 60 ; temp . seconds %= 60 ; temp . minutes += rhs . minutes ; temp . hours += temp . minutes / 60 ; temp . minutes %= 60 ; temp . hours += rhs . hours ; return temp ; } Tenga en cuenta que un operador unario definido como un método de clase no recibiría ningún argumento aparente (solo funciona desde this):
bool Tiempo :: operador ! () const { return horas == 0 && minutos == 0 && segundos == 0 ; } El operador menor que (<) a menudo se sobrecarga para ordenar una estructura o clase:
clase Par { público : bool operador < ( const Par & p ) const { si ( x_ == p.x_ ) { devolver y_ < p.y_ ; } devolver x_ < p.x_ ; } privado : int x_ ; int y_ ; }; Al igual que en los ejemplos anteriores, en el último ejemplo la sobrecarga de operadores se realiza dentro de la clase. En C++, después de sobrecargar el operador menor que (<), se pueden utilizar funciones de ordenación estándar para ordenar algunas clases.
La sobrecarga de operadores ha sido criticada a menudo [2] porque permite a los programadores reasignar la semántica de los operadores dependiendo de los tipos de sus operandos. Por ejemplo, el uso del <<operador en C++ desplaza los bits en la variable que quedan por bits si y son de un tipo entero, pero si es un flujo de salida, entonces el código anterior intentará escribir a en el flujo. Debido a que la sobrecarga de operadores permite al programador original cambiar la semántica habitual de un operador y tomar por sorpresa a los programadores posteriores, se considera una buena práctica utilizar la sobrecarga de operadores con cuidado (los creadores de Java decidieron no utilizar esta característica, [3] aunque no necesariamente por esta razón).a << bababab
Otro problema, más sutil, con los operadores es que ciertas reglas de las matemáticas pueden esperarse erróneamente o asumirse involuntariamente. Por ejemplo, la conmutatividad de + (es decir, que a + b == b + a) no siempre se aplica; un ejemplo de esto ocurre cuando los operandos son cadenas, ya que + se sobrecarga comúnmente para realizar una concatenación de cadenas (es decir, "bird" + "song"produce "birdsong", mientras que "song" + "bird"produce "songbird"). Un contraargumento típico [ cita requerida ] a este argumento proviene directamente de las matemáticas: Si bien + es conmutativo en números enteros (y más generalmente en cualquier número complejo), no es conmutativo para otros "tipos" de variables. En la práctica, + ni siquiera es siempre asociativo , por ejemplo con valores de punto flotante debido a errores de redondeo. Otro ejemplo: en matemáticas, la multiplicación es conmutativa para números reales y complejos, pero no es conmutativa en la multiplicación de matrices .
Se realiza una clasificación de algunos lenguajes de programación comunes según si sus operadores son sobrecargables por el programador y si los operadores están limitados a un conjunto predefinido.
La especificación ALGOL 68 permitía la sobrecarga de operadores. [44]
Extracto de la especificación del lenguaje ALGOL 68 (página 177) donde se definen los operadores sobrecargados ¬, =, ≠ y abs :
10.2.2. Operaciones con operandos booleanosa) op ∨ = ( bool a, b) bool :( a | verdadero | b );b) op ∧ = ( bool a, b) bool : ( a | b | falso );c) op ¬ = ( bool a) bool : ( a | falso | verdadero );d) op = = ( bool a, b) bool :( a∧b ) ∨ ( ¬b∧¬a );e) op ≠ = ( bool a, b) bool : ¬(a=b);f) op abs = ( bool a) int : ( a | 1 | 0 );
Tenga en cuenta que no se necesita ninguna declaración especial para sobrecargar un operador y que el programador tiene libertad para crear nuevos operadores. En el caso de los operadores diádicos, se puede establecer su prioridad en comparación con otros operadores:
prioridad máxima = 9; op máx = ( int a, b) int : ( a>b | a | b ); op ++ = ( ref int a ) int : ( a +:= 1 );
Ada admite la sobrecarga de operadores desde su inicio, con la publicación del estándar de lenguaje Ada 83. Sin embargo, los diseñadores del lenguaje decidieron evitar la definición de nuevos operadores. Solo se pueden sobrecargar los operadores existentes en el lenguaje, definiendo nuevas funciones con identificadores como "+", "*", "&", etc. Las revisiones posteriores del lenguaje (en 1995 y 2005) mantienen la restricción a la sobrecarga de operadores existentes.
En C++ , la sobrecarga de operadores es más refinada que en ALGOL 68. [ 45]
Los diseñadores del lenguaje Java en Sun Microsystems decidieron omitir la sobrecarga. [46] [47] [48]
Python permite la sobrecarga de operadores a través de la implementación de métodos con nombres especiales. [49] Por ejemplo, el operador de suma (+) se puede sobrecargar implementando el método obj.__add__(self, other).
Ruby permite la sobrecarga de operadores como azúcar sintáctica para llamadas a métodos simples.
Lua permite la sobrecarga de operadores como azúcar sintáctica para llamadas a métodos con la característica adicional de que si el primer operando no define ese operador, se utilizará el método para el segundo operando.
Microsoft agregó la sobrecarga de operadores a C# en 2001 y a Visual Basic .NET en 2003.
Scala trata a todos los operadores como métodos y por lo tanto permite la sobrecarga de operadores por proxy.
En Raku , la definición de todos los operadores se delega en funciones léxicas y, por lo tanto, mediante definiciones de funciones, se pueden sobrecargar operadores o agregar operadores nuevos. Por ejemplo, la función definida en el código fuente de Rakudo para incrementar un objeto Date con "+" es:
multi infijo:<+> ( Fecha:D $d , Int:D $x ) { Fecha . nuevo-desde-daycount ( $d . daycount + $x )}Dado que se utilizó "multi", la función se agrega a la lista de candidatos de multidispatch , y "+" solo se sobrecarga en el caso en que se cumplan las restricciones de tipo en la firma de la función. Si bien la capacidad de sobrecarga incluye + , * , >= , el sufijo y el término i , etc., también permite la sobrecarga de varios operadores de llaves: " [ x, y ] ", "x [ y ] ", "x { y } " y "x ( y ) ".
Kotlin ha admitido la sobrecarga de operadores desde su creación.
{{cite web}}: Verificar |url=valor ( ayuda )Una de las mejores características de C++ OOP es que puedes sobrecargar operadores para manejar objetos de tus clases (no puedes hacer esto en otros lenguajes centrados en OOP, como Java).