35 Operadores sobrecargados
Ya habíamos visto el funcionamiento de los operadores sobrecargados en el capítulo 22, aplicándolos a operaciones con estructuras. Ahora veremos todo su potencial, aplicándolos a clases.
Sobrecarga de operadores binarios
Empezaremos por los operadores binarios, que como recordarás son aquellos que requieren dos operandos, como la suma o la resta.
Existe una diferencia entre la sobrecarga de operadores que vimos anteriormente, que se definían fuera de las clases. Cuando se sobrecargan operadores en el interior se asume que el primer operando es el propio objeto de la clase donde se define el operador. Debido a esto, sólo se necesita especificar un operando.
Sintaxis:
<tipo> operator<operador binario>(<tipo> <identificador>);
Normalmente el <tipo> es la clase para la que estamos sobrecargando el operador, tanto en el valor de retorno como en el parámetro.
Veamos un ejemplo para una clase para el tratamiento de tiempos:
#include <iostream>
using namespace std;
class Tiempo {
public:
Tiempo(int h=0, int m=0) : hora(h), minuto(m) {}
void Mostrar();
Tiempo operator+(Tiempo h);
private:
int hora;
int minuto;
};
Tiempo Tiempo::operator+(Tiempo h) {
Tiempo temp;
temp.minuto = minuto + h.minuto;
temp.hora = hora + h.hora;
if(temp.minuto >= 60) {
temp.minuto -= 60;
temp.hora++;
}
return temp;
}
void Tiempo::Mostrar() {
cout << hora << ":" << minuto << endl;
}
int main() {
Tiempo Ahora(12,24), T1(4,45);
T1 = Ahora + T1; // (1)
T1.Mostrar();
(Ahora + Tiempo(4,45)).Mostrar(); // (2)
return 0;
}
Ejecutar este código en OnlineGDB.
Me gustaría hacer algunos comentarios sobre el ejemplo:
Observa que cuando sumamos dos tiempos obtenemos un tiempo, se trata de una propiedad de la suma, todos sabemos que no se pueden sumar peras y manzanas.
Pero en C++ sí se puede. Por ejemplo, podríamos haber sobrecargado el operador suma de este modo:
int operator+(Tiempo h);
Pero no estaría muy clara la naturaleza del resultado, ¿verdad?. Lo lógico es que la suma de dos objetos produzca un objeto del mismo tipo o la misma clase.
Hemos usado un objeto temporal para calcular el resultado de la suma, esto es necesario porque necesitamos operar con los minutos para prevenir el caso en que excedan de 60, en cuyo caso incrementaremos el tiempo en una hora.
Ahora observa cómo utilizamos el operador en el programa.
La forma (1) es la forma más lógica, para eso hemos creado un operador, para usarlo igual que en las situaciones anteriores.
Pero verás que también hemos usado el operador =, a pesar de que nosotros no lo hemos definido. Esto es porque el compilador crea un operador de asignación por defecto si nosotros no lo hacemos, pero veremos más sobre eso en el siguiente punto.
La forma (2) es una pequeña aberración, pero ilustra cómo es posible crear objetos temporales sin nombre.
En esta línea hay dos, el primero Tiempo(4,45), que se suma a Ahora para producir otro objeto temporal sin nombre, que es el que mostramos en pantalla.
Sobrecargar el operador de asignación: ¿por qué?
Ya sabemos que el compilador crea un operador de asignación por defecto si nosotros no lo hacemos, así que ¿por qué sobrecargarlo?
Bueno, veamos lo que pasa si nuestra clase tiene miembros que son punteros, por ejemplo:
class Cadena {
public:
Cadena(char *cad);
Cadena() : cadena(NULL) {};
~Cadena() { delete[] cadena; };
void Mostrar() const;
private:
char *cadena;
};
Cadena::Cadena(char *cad) {
cadena = new char[strlen(cad)+1];
strcpy(cadena, cad);
}
void Cadena::Mostrar() const {
cout << cadena << endl;
}
Si en nuestro programa declaramos dos objetos de tipo Cadena:
Cadena C1("Cadena de prueba"), C2;
Y hacemos una asignación:
C2 = C1;
Lo que realmente copiamos no es la cadena, sino el puntero. Ahora los dos punteros de las cadenas C1 y C2 están apuntando a la misma dirección. ¿Qué pasará cuando destruyamos los objetos? Al destruir C1 se intentará liberar la memoria de su puntero cadena, y al destruir C2 también, pero ambos punteros apuntan a la misma dirección y el valor original del puntero de C2 se ha perdido, por lo que su memoria no puede ser liberada.
En estos casos, análogamente a lo que sucedía con el constructor copia, deberemos sobrecargar el operador de asignación. En nuestro ejemplo podría ser así:
Cadena &Cadena::operator=(const Cadena &c) {
if(this != &c) {
delete[] cadena;
if(c.cadena) {
cadena = new char[strlen(c.cadena)+1];
strcpy(cadena, c.cadena);
}
else cadena = NULL;
}
return *this;
}
Hay que tener en cuenta la posibilidad de que se asigne un objeto a si mismo. Por eso comparamos el puntero this con la dirección del parámetro, si son iguales es que se trata del mismo objeto, y no debemos hacer nada. Esta es una de las situaciones en las que el puntero this es imprescindible.
También hay que tener cuidado de que la cadena a copiar no sea NULL, en ese caso no debemos copiar la cadena, sino sólo asignar NULL a cadena.
Y por último, también es necesario retornar una referencia al objeto, esto nos permitirá escribir expresiones como estas:
C1 = C2 = C3; if((C1 = C2) == C3)...
Por supuesto, para el segundo caso deberemos sobrecargar también el operador ==.
Operadores binarios que pueden sobrecargarse
Además del operador + pueden sobrecargarse prácticamente todos los operadores:
+, -, *, /, %, ^, &, |, (,), <, >, <=, >=, <<, >>, ==, !=, &&, ||, =, +=. -=, *=, /=, %=, ^=, &=, |=, <<=,>>=, [], (),->, new y delete.
Los operadores =, [], () y -> sólo pueden sobrecargarse en el interior de clases.
Por ejemplo, el operador > podría declararse y definirse así:
class Tiempo {
...
bool operator>(Tiempo h);
...
};
bool Tiempo::operator>(Tiempo h) {
return (hora > h.hora ||
(hora == h.hora && minuto > h.minuto));
}
...
if(Tiempo(1,32) > Tiempo(1,12))
cout << "1:32 es mayor que 1:12" << endl;
else
cout << "1:32 es menor o igual que 1:12" << endl;
...
Para los operadores de igualdad el valor de retorno es bool, lógicamente, ya que estamos haciendo una comparación.
Y el operador +=, de esta otra:
class Tiempo {
...
void operator+=(Tiempo h);
...
};
void Tiempo::operator+=(Tiempo h) {
minuto += h.minuto;
hora += h.hora;
while(minuto >= 60) {
minuto -= 60;
hora++;
}
}
...
Ahora += Tiempo(1,32);
Ahora.Mostrar();
...
Los operadores de asignación mixtos no necesitan valor de retorno, ya que es el propio objeto al que se aplican el que recibe el resultado de la operación y además, no pueden asociarse.
Con el resto de lo operadores binarios se trabaja del mismo modo.
No es imprescindible mantener el significado de los operadores. Por ejemplo, para la clase Tiempo no tiene sentido sobrecargar el operadores >>, <<, * ó /, pero podemos hacerlo de todos modos, y olvidar el significado que tengan habitualmente. De igual modo podríamos haber sobrecargado el operador + y hacer que no sumara los tiempos sino que, por ejemplo, los restara. En última instancia, es el programador el que decide el significado de los operadores.
Por ejemplo, sobrecargaremos el operador >> para que devuelva el mayor de los operandos.
class Tiempo {
...
Tiempo operator>>(Tiempo h);
...
};
Tiempo Tiempo::operator>>(Tiempo h) {
if(*this > h) return *this; else return h;
}
...
T1 = Ahora >> Tiempo(13,43) >> T1 >> Tiempo(12,32);
T1.Mostrar();
...
En este ejemplo hemos recurrido al puntero this, para usar el objeto actual en una comparación y para devolverlo como resultado en el caso adecuado.
Esta es otra de las aplicaciones del puntero this, si no dispusiéramos de él, sería imposible hacer referencia al propio objeto al que se aplica el operador.
También vemos que los operadores binarios deben seguir admitiendo la asociación aún estando sobrecargados.
Forma funcional de los operadores
Por supuesto también es posible usar la forma funcional de los operadores sobrecargados, aunque no es muy habitual ni demasiado aconsejable.
En el caso del operador + las siguientes expresiones son equivalentes:
T1 = T1.operator+(Ahora); T1 = Ahora + T1;
Sobrecarga de operadores para clases con punteros
Si intentamos sobrecargar el operador suma con la clase Cadena usando el mismo sistema que con Tiempo, veremos que no funciona.
Cuando nuestras clases tienen punteros con memoria dinámica asociada, la sobrecarga de funciones y operadores puede complicarse un poco.
Por ejemplo, sobrecarguemos el operador + para la clase Cadena. El significado, en este caso, será concatenar las cadenas sumadas:
class Cadena {
...
Cadena operator+(const Cadena &);
...
};
Cadena Cadena::operator+(const Cadena &c) {
Cadena temp;
temp.cadena = new char[strlen(c.cadena)+strlen(cadena)+1];
strcpy(temp.cadena, cadena);
strcat(temp.cadena, c.cadena);
return temp;
}
...
Cadena C1, C2("Primera parte");
C1 = C2 + " Segunda parte";
Ahora analicemos cómo funciona el código de este operador.
El equivalente de ésta última línea es:
C1.operator=(Cadena(C2.operator+(Cadena(" Segunda parte"))));
Si aplicamos la precedencia a esta expresión, tenemos la siguiente secuencia:
1) Se crea automáticamente un objeto temporal sin nombre para la cadena " Segunda parte". Y se llama al operador + del objeto C2.
2) Dentro del operador + se crea un objeto temporal: temp, reservamos memoria para la cadena que almacenará la concatenación de this->cadena y c.cadena, y le asignamos el valor de ambas cadenas, temp contiene la cadena: "Primera parte Segunda parte".
3) Retornamos el objeto temporal.
4) Ahora el objeto temporal temp se copia a otro objeto temporal sin nombre, y temp es destruido. Y el objeto temporal sin nombre se pasa como parámetro al operador de asignación.
Cuando hablamos del ámbito temporal de los objetos locales o automáticos, vimos que éstos son destruidos tan pronto se abandona el ámbito al que pertenecen. Esto es lo que pasa con el objeto temp en el operador +. Sin embargo, parece ser que ese es precisamente el objeto que devolvemos. En realidad, el compilador crea otro objeto temporal, y copia en él el valor de temp antes de destruirlo y abandonar su ámbito.
Si esto es difícil de entender, piensa lo que pasa cuando usamos el operador de asignación con una cadena, por ejemplo:
C1 = "hola";
En este caso se crea un objeto temporal sin nombre para "hola", igual que pasó con la cadena " Segunda parte".
5) Se asigna el objeto temporal sin nombre a C1, y se destruye.
Parece que todo ha ido bien, pero en el paso 4 hay un problema. Para copiar temp en el objeto temporal sin nombre se usa el constructor copia de Cadena.
¡Ah!, pero como nosotros no hemos definido un constructor copia, de modo que se usará el constructor copia por defecto. Recuerda que ese constructor copia los punteros, no los contenidos de estos.
Recapitulemos: el objeto temp se copia en un temporal sin nombre, y después se destruye, ¿qué pasa con el dato temp.cadena?, evidentemente también se destruye, pero el constructor copia por defecto ha copiado ese puntero, por lo tanto, también su cadena es destruida. El resultado es que C1 no recibe la suma de las cadenas.
Para evitar eso tenemos que sobrecargar el constructor copia
En este ejemplo es sencillo ya que disponemos del operador de asignación. No debemos olvidar que hay que inicializar los datos miembros, el constructor copia no deja de ser un constructor:
class Cadena {
...
Cadena(const Cadena &c) : cadena(NULL) { *this = c; }
...
};
Si no tenemos cuidado de iniciar el valor de cadena, cuando se invoque al operador "=" el puntero cadena tendrá algún valor inválido, y al ejecutar el código del operador de asignación se producirá un error al intentar liberarlo.
Cadena &Cadena::operator=(const Cadena &c) {
if(this != &c) {
delete[] cadena; // (1)
if(c.cadena) {
cadena = new char[strlen(c.cadena)+1];
strcpy(cadena, c.cadena);
}
else cadena = NULL;
}
return *this;
}
En (1), si cadena no es NULL, pero tampoco es un puntero válido, se producirá un error de ejecución. En general, si se usa el operador de asignación con objetos que existan no habrá problema, pero si se usa desde el constructor copia debemos asegurarnos de que el puntero es NULL.
Nota: La moraleja es que cuando nuestras clases tengan datos miembro que sean punteros a memoria dinámica debemos sobrecargar siempre el constructor copia, ya que nunca sabemos cuándo puede ser invocado sin que nos demos cuenta.
(Gracias a Steven por la idea de crear una clase Tiempo como ejemplo para la sobrecarga de operadores)
Notas sobre este tema
Esto es sólo un comentario sobre algunos aspectos curiosos de los compiladores.
Puede que el compilador optimice el código de modo que no se cree el objeto copia del objeto temporal creado en el operador suma. Esto pasará si el compilador lo permite, y si lo permite el modelo de memoria utilizado. Por ejemplo, en Windows, con un modelo de memoria virtual, en el que no se distingue la memoria del montón de la pila o de la memoria local, es posible usar las direcciones de memoria del objeto creado para un objeto automático de un operador o función para un objeto automático de otra función o para uno global.
Así pasará en nuestro ejemplo con el objeto temp creado en el operador suma. Se trata de un objeto automático, y por lo tanto, local al operador. En algunos sistemas operativos este objeto se creará en una zona de memoria local (por ejemplo, la pila), y no estará accesible al retornar a la función main, desde el que fue invocado. En ese caso, el compilador creará una copia, invocando al constructor copia, y después destruirá el objeto temporal.
Con un modelo de memoria como el que usar Windows de 32 bits, por ejemplo, esto no es necesario, y el objeto puede ser persistente, aunque haya terminado su ámbito.
Pero hay que tener presente que esto es una optimización, y que en ningún caso puede ser tomado como una comportamiento general.
El siguiente ejemplo funcionará correctamente en Windows XP, y en otros sistemas operativos, a pesar de que se ha omitido intencionadamente el código para el constructor copia:
#include <cstring>
#include <iostream>
using namespace std;
class Cadena {
public:
Cadena(const char *cad);
Cadena() : cadena(0) { cout << "Constructor sin parametros" << endl; };
Cadena(const Cadena &c);
~Cadena();
Cadena &operator=(const Cadena &c);
Cadena operator+(const Cadena &);
void Mostrar() const;
private:
char *cadena;
};
Cadena::Cadena(const char *cad) {
cadena = new char[strlen(cad)+1];
strcpy(cadena, cad);
cout << "Constructor (" << cad <<") [" << (void*)cadena << "]" << endl;
}
Cadena::Cadena(const Cadena &) {} // NO HACE NADA
Cadena::~Cadena() {
cout << "Destructor (" << cadena << ") [" << (void*)cadena << "]" << endl;
delete[] cadena;
}
void Cadena::Mostrar() const {
cout << cadena << endl;
}
Cadena &Cadena::operator=(const Cadena &c) {
cout << "Asignacion" << endl;
if(this != &c) {
delete[] cadena;
if(c.cadena) {
cadena = new char[strlen(c.cadena)+1];
strcpy(cadena, c.cadena);
}
else cadena = 0;
}
return *this;
}
Cadena Cadena::operator+(const Cadena &c) {
cout << "suma-";
Cadena temp;
temp.cadena = new char[strlen(c.cadena)+strlen(this->cadena)+1];
strcpy(temp.cadena, this->cadena);
strcat(temp.cadena, c.cadena);
return temp;
}
int main() {
Cadena C1("Hola"), C2("Adios"), C3("");
C3 = C1 + ", mundo!";
C3.Mostrar();
(C2+", mundo").Mostrar();
return 0;
}
La salida puede ser:
Constructor (Hola) [0x3e3d90] <- C1 en main Constructor (Adios) [0x3e3df8] <- C2 en main Constructor () [0x3e3e08] <- C3 en main Constructor (, mundo!) [0x3e3e18] <- C4 en main suma-Constructor sin parametros <- temp en operator+ Asignacion <- Asignación a C3 Destructor (Hola, mundo!) [0x3e3e30] <- Destrucción de objeto temporal, una vez asignado Destructor (, mundo!) [0x3e3e18] <- Destrucción de objeto temporal de suma Hola, mundo! <- Mostrar() Constructor (, mundo) [0x3e3e08] <- C2+", mundo"; // Segundo operando en suma suma-Constructor sin parametros <- temp en operator+ Adios, mundo <- Mostrar() Destructor (Adios, mundo) [0x3e3e18] <- Destrucción de objeto temporal Cadena(C2+",mundo") Destructor (, mundo) [0x3e3e08] <- Destrucción de objeto temporal de suma Destructor (Hola, mundo!) [0x3e3e48] <- Destrucción de C3 Destructor (Adios) [0x3e3df8] <- Destrucción de C2 Destructor (Hola) [0x3e3d90] <- Destrucción de C1
Sin embargo, en otros compiladores, es imprescindible crear correctamente el constructor copia, y se usará para pasar los objetos temporales automáticos entre distintos ámbitos de acceso y duración.
El código para el constructor copia podría ser:
Cadena::Cadena(const Cadena &c) {
cadena = new char[strlen(c.cadena)+1];
strcpy(cadena, c.cadena);
cout << "Constructor copia (" << cadena << ") [" << (void*)cadena << "]" << endl;
}
Ejecutar este código en OnlineGDB.
La salida de este programa en un compilador que invoque el contructor copia sería:
Constructor (Hola) [0x8051438] <- C1 en main
Constructor (Adios) [0x8051568] <- C2 en main
Constructor () [0x8051590] <- C3 en main
Constructor (, mundo!) [0x80515b0] <- C1+Cadena(", mundo"); // Segundo operando en suma en main
suma-Constructor sin parametros <- temp en operator+
Constructor copia (Hola, mundo!) [0x80515d8] <- copia para cambio de ámbito
Destructor (Hola, mundo!) [0x80514e8] <- destrucción de temp
Asignacion <- Asignación a C3
Destructor (Hola, mundo!) [0x80515d8] <- Destrucción de objeto temporal, una vez asignado
Destructor (, mundo!) [0x80515b0] <- Destrucción de objeto temporal de suma
Hola, mundo! <- Mostrar()
Constructor (, mundo) [0x80515b0] <- C2+", mundo"; // Segundo operando en suma
suma-Constructor sin parametros <- temp en operator+
Constructor copia (Adios, mundo) [0x8051608] <- copia para cambio de ámbito
Destructor (Adios, mundo) [0x80515d8] <- destrucción de temp
Adios, mundo <- Mostrar()
Destructor (Adios, mundo) [0x8051608] <- Destrucción de objeto temporal Cadena(C2+",mundo")
Destructor (, mundo) [0x80515b0] <- Destrucción de objeto temporal de suma
Destructor (Hola, mundo!) [0x80514e8] <- Destrucción de C3
Destructor (Adios) [0x8051568] <- Destrucción de C2
Destructor (Hola) [0x8051438] <- Destrucción de C1
He resaltado en negrita las diferencias entre un programa y el otro, que corresponden con las creaciones y destrucciones de los objetos temporales necesarios al cambiar de ámbito, que no se hacen en el primer ejemplo.
Sobrecarga de operadores unitarios
Ahora le toca el turno a los operadores unitarios, que son aquellos que sólo requieren un operando, como la asignación o el incremento.
Cuando se sobrecargan operadores unitarios en una clase el operando es el propio objeto de la clase donde se define el operador. Por lo tanto los operadores unitarios dentro de las clases no requieren parámetros
Sintaxis:
<tipo> operator<operador unitario>();
Normalmente el <tipo> es la clase para la que estamos sobrecargando el operador. Sigamos con el ejemplo de la clase para el tratamiento de tiempos, sobrecargaremos ahora el operador de incremento ++:
class Tiempo {
...
Tiempo operator++();
...
};
Tiempo Tiempo::operator++() {
minuto++;
while(minuto >= 60) {
minuto -= 60;
hora++;
}
return *this;
}
...
T1.Mostrar();
++T1;
T1.Mostrar();
...
Operadores unitarios sufijos
Lo que hemos visto vale para el preincremento, pero, ¿cómo se sobrecarga el operador de postincremento?
En realidad no hay forma de decirle al compilador cuál de las dos modalidades del operador estamos sobrecargando, así que los compiladores usan una regla: si se declara un parámetro para un operador ++ ó -- se sobrecargará la forma sufija del operador. El parámetro se ignorará, así que bastará con indicar el tipo.
También tenemos que tener en cuenta el peculiar funcionamiento de los operadores sufijos, cuando los sobrecarguemos, al menos si queremos mantener el comportamiento que tienen normalmente.
Cuando se usa un operador en la forma sufijo dentro de una expresión, primero se usa el valor actual del objeto, y una vez evaluada la expresión, se aplica el operador. Si nosotros queremos que nuestro operador actúe igual deberemos usar un objeto temporal, y asignarle el valor actual del objeto. Seguidamente aplicamos el operador al objeto actual y finalmente retornamos el objeto temporal.
Veamos un ejemplo:
class Tiempo {
...
Tiempo operator++(); // Forma prefija
Tiempo operator++(int); // Forma sufija
...
};
Tiempo Tiempo::operator++() {
minuto++;
while(minuto >= 60) {
minuto -= 60;
hora++;
}
return *this;
}
Tiempo Tiempo::operator++(int) {
Tiempo temp(*this); // Constructor copia
minuto++;
while(minuto >= 60) {
minuto -= 60;
hora++;
}
return temp;
}
...
// Prueba:
T1.Mostrar();
(T1++).Mostrar();
T1.Mostrar();
(++T1).Mostrar();
T1.Mostrar();
...
Salida:
17:9 (Valor inicial)
17:9 (Operador sufijo, el valor no cambia
hasta después de mostrar el valor)
17:10 (Resultado de aplicar el operador)
17:11 (Operador prefijo, el valor cambia
antes de mostrar el valor)
17:11 (Resultado de aplicar el operador)
Operadores unitarios que pueden sobrecargarse
Además del operador ++ y -- pueden sobrecargarse prácticamente todos los operadores unitarios:
+, -, ++, --, *, & y !.
Operadores de conversión de tipo
Volvamos a nuestra clase Tiempo. Imaginemos que queremos hacer una operación como la siguiente:
Tiempo T1(12,23); unsigned int minutos = 432; T1 += minutos;
Con toda probabilidad no obtendremos el valor deseado.
Como ya hemos visto, en C++ se realizan conversiones implícitas entre los tipos básicos antes de operar con ellos, por ejemplo para sumar un int y un float, se convierte el entero a float. Esto se hace también en nuestro caso, pero no como esperamos.
El valor "minutos" se convierte a un objeto Tiempo, usando el constructor que hemos diseñado. Como sólo hay un parámetro, el parámetro m toma el valor 0, y para el parámetro h se convierte el valor "minutos" de unsigned int a int.
El resultado es que se suman 432 horas, cuando nosotros queremos sumar 432 minutos.
Esto se soluciona creando un nuevo constructor que tome como parámetro un unsigned int.
Tiempo(unsigned int m) : hora(0), minuto(m) {
while(minuto >= 60) {
minuto -= 60;
hora++;
}
}
Ahora el resultado será el adecuado.
En general podremos hacer conversiones de tipo desde cualquier objeto a un objeto de nuestra clase sobrecargando el constructor.
Pero también se puede presentar el caso contrario. Ahora queremos asignar a un entero un objeto Tiempo:
Tiempo T1(12,23); int minutos; minutos = T1;
En este caso obtendremos un error de compilación, ya que el compilador no sabe convertir un objeto Tiempo a entero.
Para eso tenemos que diseñar nuestro operador de conversión de tipo, que se aplicará automáticamente.
Los operadores de conversión de tipos tienen el siguiente formato:
operator <tipo>();
No necesitan que se especifique el tipo del valor de retorno, ya que este es precisamente <tipo>. Además, al ser operadores unitarios, tampoco requieren argumentos, puesto que se aplican al propio objeto.
class Tiempo {
...
operator int();
...
operator int() {
return hora*60+minuto;
}
Por supuesto, el tipo no tiene por qué ser un tipo básico, puede tratarse de una estructura o una clase.
Sobrecarga del operador de indexación []
El operador [] se usa para acceder a valores de objetos de una determinada clase como si se tratase de arrays. Los índices no tienen por qué ser de un tipo entero o enumerado, cuando se sobrecarga este operador no existe esa limitación.
Donde más útil resulta este operador es cuando se usa con estructuras dinámicas de datos: listas y árboles. Pero también puede servirnos para crear arrays asociativos, donde los índices sean por ejemplo, palabras.
De nuevo explicaremos el uso de este operador usando un ejemplo.
Supongamos que hacemos una clase para hacer un histograma de los valores de rand()/RAND_MAX, entre los márgenes de 0 a 0.0009, de 0.001 a 0.009, de 0.01 a 0.09 y de 0.1 a 1.
Nota:
Un histograma es un gráfico o una tabla utilizado en la representación de distribuciones de frecuencias de cualquier tipo de información o función. La clase de nuestro ejemplo podría usar los valores de la tabla para generar ese gráfico.
#include <iostream>
using namespace std;
class Cuenta {
public:
Cuenta() { for(int i = 0; i < 4; contador[i++] = 0); }
int &operator[](double n); // (1)
void Mostrar() const;
private:
int contador[4];
};
int &Cuenta::operator[](double n) { // (2)
if(n < 0.001) return contador[0];
else if(n < 0.01) return contador[1];
else if(n < 0.1) return contador[2];
else return contador[3];
}
void Cuenta::Mostrar() const {
cout << "Entre 0 y 0.0009: " << contador[0] << endl;
cout << "Entre 0.0010 y 0.0099: " << contador[1] << endl;
cout << "Entre 0.0100 y 0.0999: " << contador[2] << endl;
cout << "Entre 0.1000 y 1.0000: " << contador[3] << endl;
}
int main() {
Cuenta C;
for(int i = 0; i < 50000; i++)
C[(double)rand()/RAND_MAX]++; // (3)
C.Mostrar();
return 0;
}
Ejecutar este código en OnlineGDB.
En este ejemplo hemos usado un valor double como índice, pero igualmente podríamos haber usado una cadena o cualquier objeto que hubiésemos querido.
El tipo del valor de retorno de operador debe ser el del objeto que devuelve (1). En nuestro caso, al tratarse de un contador, devolvemos un entero. Bueno, en realidad devolvemos una referencia a un entero, de este modo podemos aplicarle el operador de incremento al valor de retorno (3).
En la definición del operador (2), hacemos un tratamiento del parámetro que usamos como índice para adaptarlo al tipo de almacenamiento que usamos en nuestra clase.
Cuando se combina el operador de indexación con estructuras dinámicas de datos como las listas, se puede trabajar con ellas como si se tratada de arrays de objetos, esto nos dará una gran potencia y claridad en el código de nuestros programas.
Sobrecarga del operador de llamada ()
El operador () funciona exactamente igual que el operador [], aunque admite más parámetros.
Este operador permite usar un objeto de la clase para el que está definido como si fuera una función.
Como ejemplo añadiremos un operador de llamada a función que admita dos parámetros de tipo double y que devuelva el mayor contador de los asociados a cada uno de los parámetros.
class Cuenta {
...
int operator()(double n, double m);
...
};
int Cuenta::operator()(double n, double m) {
int i, j;
if(n < 0.001) i = 0;
else if(n < 0.01) i = 1;
else if(n < 0.1) i = 2;
else i = 3;
if(m < 0.001) j = 0;
else if(m < 0.01) j = 1;
else if(m < 0.1) j = 2;
else j = 3;
if(contador[i] > contador[j]) return contador[i];
else return contador[j];
}
...
cout << C(0.0034, 0.23) << endl;
...
Por supuesto, el número de parámetros, al igual que el tipo de retorno de la función depende de la decisión del programador.