0
Operadores V: Operadores sobrecargados
Al igual que sucede con las funciones, en C++ los operadores también pueden sobrecargarse.
En realidad la mayoría de los operadores en C++ ya están sobrecargados. Por ejemplo el operador + realiza distintas acciones cuando los operandos son enteros, o en coma flotante. En otros casos esto es más evidente, por ejemplo el operador * se puede usar como operador de multiplicación o como operador de indirección.
C++ permite al programador sobrecargar a su vez los operadores para sus propios usos o para sus propios tipos.
Sintaxis:
Prototipo:
|
<tipo> operator <operador> (<argumentos>);
|
Definición:
|
<tipo> operator <operador> (<argumentos>)
{
<sentencias>;
} |
También existen algunas limitaciones para la sobrecarga de operadores:
-Se pueden sobrecargar todos los operadores excepto ".", ".*", "::" y "?:".
-Los operadores "=", "[]", "->", "()", "new" y "delete", sólo pueden ser sobrecargados cuando se definen como de una clase.
-Los argumentos deben ser tipos enumerados o estructurados: struct, union o class.
-El número de argumentos viene predeterminado dependiendo del operador.
Operadores binarios
Antes de nada, mencionar que el tipo del valor de retorno y el de los parámetros no está limitado.
Aunque la lógica de cada operador nos imponga ciertos tipos, hay que distinguir entre las limitaciones y obligaciones del lenguaje y las de las operaciones que estemos programando.
Por ejemplo, si queremos sobrecargar el operador suma para complejos, tendremos que sumar dos números complejos y el resultado será un número complejo.
Sin embargo, C++ nos permite definir el operador suma de modo que tome un complejo y un entero y devuelva un valor en coma flotante, por ejemplo.
Las limitaciones de C++ para operadores binarios es que uno de los parámetros debe ser de tipo estructura, clase o enumerado y que debe haber uno o dos parámetros.
Esta flexibilidad nos permite definir operadores que funcionen de forma diferente dependiendo de los tipos de los operandos. Podemos, por ejemplo, para los números complejos definir un operador que de resultados diferentes si se suma un complejo con un entero o con un número en coma flotante o con otro complejo.
Ejemplo:
|
/* Definición del operador + para complejos */
complejo operator +(complejo a, complejo b) {
complejo temp = {a.a+b.a, a.b+b.b};
return temp;
}
/* Definición del operador + para un complejo y un float */
complejo operator +(complejo a, float b) {
complejo temp = {a.a+b, a.b};
return temp;
}
/* Definición del operador + para un complejos y un entero (arbitrariamente) */
int operator +(complejo a, int b) {
return int(a.b)+b;
} |
Al igual que con las funciones sobrecargadas, la versión del operador que se usará se decide durante la fase de compilación, después del análisis de los argumentos.
Operadores unitarios
También es posible sobrecargar los operadores de preincremento, postincremento, predecremento y postdecremento.
De hecho, es posible sobrecargar otros operadores de forma unitaria, como el +, -, * o & de forma prefija.
En estos casos, el operador sólo afecta a un operando. Veamos primero los de prefijos:
Forma prefija
|
/* Definición del operador ++ prefijo para complejos */
complejo operator ++(complejo &c) {
c.a++;
return c;
} |
Evidentemente, el operador afecta al operando, modificando su valor, por lo tanto, tendremos que pasar una referencia.
Hemos definido el operador de preincremento para complejo de modo que sólo se incremente la parte real, dejando la imaginaria con el mismo valor.
Forma sufija
En el caso de los operadores sufijos tenemos un problema. El operador es el mismo, por lo tanto, no hay forma de distinguir qué versión estamos sobrecargando. Lo que está claro es que la definición anterior corresponde a la versión prefija, ya que el valor del operando cambia antes de que se evalúe cualquier expresión donde aparezca este operador:
|
complejo a, b, c;
...
c = ++a + b; |
El valor de a cambia antes de que se calcule el valor de c.
Para resolver este inconveniente se creó una regla arbitraria que consiste en añadir un parámetro de tipo int a la declaración del operador, cuando se trate de la versión sufija:
|
/* Definición del operador ++ sufijo para complejos */
complejo operator ++(complejo &c, int) {
complejo temp = {c.a, c.b};
c.a++;
return temp;
} |
Vemos que este segundo parámetro no se usa, de hecho, ni siquiera le asignamos un identificador.
Sólo sirve para que el compilador sepa que estamos definiendo (o en el caso de un prototipo, declarando) la versión sufija del operador.
La forma de definir estos operadores es siempre similar, si es que queremos mantener un funcionamiento análogo al predefinido, claro:
-Creamos un objeto temporal copia del valor inicial.
-Modificamos el valor del objeto, que como lo hemos recibido por referencia, mantendrá el valor al regresar.
-Retornamos el objeto temporal.
De este modo, el valor del objeto será modificado, pero en la expresión donde aparezca se tomará el valor antes de modificarse.
Ejemplo completo:
|
// Sobrecarga de operadores
// (C) 2009 Con Clase
// Salvador Pozo
#include <iostream>
using namespace std;
struct complejo {
float a,b;
};
/* Prototipo del operador + para complejos */
complejo operator +(complejo a, complejo b);
/* Prototipo del operador ++ prefijo para complejos */
complejo operator ++(complejo &a);
/* Prototipo del operador ++ sufijo para complejos */
complejo operator ++(complejo &a, int);
void Mostrar(complejo);
int main() {
complejo x = {10,32};
complejo y = {21,12};
complejo z;
/* Uso del operador sobrecargado + con complejos */
z = x + y;
cout << "z = (x + y) = ";
Mostrar(z);
cout << "++z = ";
Mostrar(++z);
cout << "z++ = ";
Mostrar(z++);
cout << "z = ";
Mostrar(z);
return 0;
}
/* Definición del operador + para complejos */
complejo operator +(complejo a, complejo b) {
complejo temp = {a.a+b.a, a.b+b.b};
return temp;
}
/* Definición del operador ++ prefijo para complejos */
complejo operator ++(complejo &c) {
c.a++;
return c;
}
/* Definición del operador ++ sufijo para complejos */
complejo operator ++(complejo &c, int) {
complejo temp = {c.a, c.b};
c.a++;
return temp;
}
void Mostrar(complejo c) {
cout << "(" << c.a << "," << c.b << ")" << endl;
}
|
Ejecutar este código en codepad.
La salida de este programa es la siguiente:
z = (x + y) = (31,44)
++z = (32,44)
z++ = (32,44)
z = (33,44)
Donde podemos apreciar que los operadores se comportan tal como se espera que lo hagan.
Operador de asignación
Consideremos un caso hipotético.
Tenemos una estructura donde uno de los es un puntero que apuntará a una zona de memoria obtenida dinámicamente, y trabajaremos con esos objetos en nuestro programa:
|
#include <iostream>
using namespace std;
struct tipo {
int *mem;
};
int main() {
tipo a, b;
a.mem = new int[10];
for(int i = 0; i < 10; i++) a.mem[i] = 0;
b = a; // (1)
cout << "b: ";
for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;
b.mem[2] = 1; // (2)
cout << "a: ";
for(int i = 0; i < 10; i++) cout << a.mem[i] << ",";
cout << endl;
cout << "b: ";
for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;
delete[] a.mem;
// delete[] b.mem; // (3)
return 0;
} |
Veamos la salida de este programa:
b: 0,0,0,0,0,0,0,0,0,0,
a: 0,0,1,0,0,0,0,0,0,0,
b: 0,0,1,0,0,0,0,0,0,0,
¿Notas algo extraño?
En (2) hemos modificado el valor de la posición 2 del vector mem del objeto b. Sin embargo, cuando mostramos los valores de los dos vectores, a y b, vemos que se han modificado las posiciones 2 en ambos. ¿por qué?
La respuesta está en la línea (1). Aquí hemos asignado a b el valor del objeto a. Pero, ¿cómo funciona esa asignación?
Evidentemente, se copian los valores de los campos de la estructura a en la estructura b. El problema es que mem es un puntero, y lo que copiamos es una dirección de memoria. Es decir, después de la asignación, a.mem y b.mem apuntan a la misma dirección de memoria, por lo tanto, las modificaciones que hagamos en uno de los objetos, se reflejan en ambos.
El mayor peligro está en sentencias como la (3), donde podríamos intentar liberar una memoria que ya ha sido liberada al hacerlo con el objeto a.
Pero estaremos de acuerdo en que este no es el comportamiento deseado cuando se asigna a un objeto el valor de otro. En este caso esperaríamos que las modificaciones en a y b fueran independientes.
El origen de todo está en que hemos usado el operador de asignación sin haberlo sobrecargado. El compilador no se ha quejado, porque este operador se define automáticamente para cualquier tipo declarado en el programa, pero la definición por defecto es copiar los valores de toda la memoria ocupada por el objeto, sin discriminar tipos, ni tener en cuenta si se trata de punteros o de otros valores.
Lo normal sería que pudiéramos sobrecargar el operador de asignación, y evitar estas situaciones. De hecho, deberíamos poder hacerlo siempre que vayamos a usarlo sobre objetos que contengan memoria dinámica.
Lamentablemente, no se puede sobrecargar este operador fuera de una clase (veremos que sí se puede hacer esto con clases en el capítulo 35).
Pero entonces, ¿qué hacemos con este problema? La solución es sustituir el operador de asignación por una función
|
// Asignación de arrays
// (C) 2009 Con Clase
// Salvador Pozo
#include <iostream>
using namespace std;
struct tipo {
int *mem;
};
void asignar(tipo&, tipo&);
int main() {
tipo a, b;
a.mem = new int[10];
for(int i = 0; i < 10; i++) a.mem[i] = 0;
asignar(b, a);
cout << "b: ";
for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;
b.mem[2] = 1;
cout << "a: ";
for(int i = 0; i < 10; i++) cout << a.mem[i] << ",";
cout << endl;
cout << "b: ";
for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;
delete[] a.mem;
delete[] b.mem;
return 0;
}
void asignar(tipo &a, tipo &b) {
if(&a != &b) {
if(a.mem) delete[] a.mem;
a.mem = new int[10];
for(int i = 0; i < 10; i++) a.mem[i] = b.mem[i];
}
} |
Ejecutar este código en codepad.
Hay dos precauciones básicas que debemos tener:
-Verificar si los objetos origen y destino son el mismo. En ese caso, no hay nada que hacer.
-Liberar la memoria dinámica que pudiera tener el objeto de destino antes de asignarle una nueva.
Notación funcional de los operadores
Los operadores sobrecargados son formas alternativas de invocar a ciertas funciones, de modo que sean más fácilmente interpretables.
Tanto es así que para cada operador es posible usarlos en su forma de función, esta forma de usar los operadores se conoce como notación funcional:
| z = operator+(x,y); |
Pero donde veremos mejor toda la potencia de los operadores sobrecargados será cuando estudiemos las clases. En el capítulo 35 veremos este tema con mayor detalle.
Palabras reservadas usadas en este capítulo
operator.
Problemas
1-Dada la sigiente estructura para almacenar ángulos en grados, minutos y segundos:
|
struct stAngulo {
int grados;
int minutos;
int segundos;
}; |
Sobrecargar los operadores de suma y resta para sumar y restar ángulos, y los operadores de incremento y decremento, tanto en sus formas sufijas como prefijas.
Hay que tener en cuenta que tanto los valores para minutos como para los segundos están limitados entre 0 y 59. Para este ejercicio, en el caso de los grados podemos limitar esos valores entre 0 y 359, aunque en general se entienden los grados negativos y los valores fuera de ese rango para indicar sentidos en los giros y para indicar múltiples vueltas.
2-Sobrecargar el operador de resta para calcular la diferencia en días entre dos fechas.
La estructura para las fechas será:
Comentarios