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 (por ejemplo: http://codepad.org), 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 codepad.

La salida de este programa en el compilador de codepad 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.

Comentarios de los usuarios (2)

javiol
2012-01-24 11:29:18

Buenas, de nuevo agradeceros este tutorial tan completo de forma desinteresada.

Tengo una duda en esta sentencia utilizada arriba para explicar la sobrecarga del operador >> en la clase Tiempo:

if(*this > h) return *this; else return h;

No entiendo *this > h, el operador > esta sobrecargado?? Es que si no no entiendo que va a comparar, ya que un objeto € Tiempo tendrá una hora y un minuto...

Muchas gracias!

javiol
2012-01-24 11:31:07

Olvidad mi comentario anterior... que ya he visto que si que está sobrecargado el operador >.