22 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 miembros 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 <i>std</i>;
 
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 miembros 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];
    b.mem = 0;
	
    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á:

    struct fecha {
       int dia;
       int mes;
       int anno;
    };
    

Comentarios de los usuarios (16)

b0ch0n
2010-11-03 00:24:16

enlace del ejercicio de angulos

http://codepad.org/CUfi2iWq

b0ch0n
2010-11-04 23:30:11

ejercicio de resta o diferencia en dias entre fechas

http://codepad.org/Pm1rMKQe

Nota del administrador: Hemos eliminado el código ya que las soluciones a los problemas no se han incluido de forma intencionada. La idea es que cada uno haga sus propios problemas a su modo.

Gato5piés
2011-05-26 11:07:49

¿Con qué prioridad se resuelven los operadores sobrecargados? ¿Heredan la precedencia de los símbolos que se sobrecargan?

Steven Davidson
2011-05-26 23:47:08

Hola Gato5piés,

La sobrecarga de operadores en C++ sólo permite agregar el comportamiento o la lógica; es decir, la semántica. No se permite modificar ningún otro aspecto de los operadores.

Esto significa que no podemos cambiar la precedencia ni asociatividad ni tipo (unitario o binario) de los operadores. Tampoco podemos modificar la semántica de los operadores que involucren los tipos fundamentales de los operandos. Por ejemplo, la semántica del operador + para 'int' e 'int' no se puede modificar, ya que el lenguaje define tal semántica. Ni tampoco podemos crear nuevos operadores.

Espero haber aclarado las dudas.

Steven

CLRG
2011-07-02 06:26:09

el problema de los angulos: http://codepad.org/gJBFePPD

Rodrigo
2013-05-17 03:33:51

En la sobrecarga del operador ++(postincremento), segun entiendo, se debe agregar static antes de la declaracion del "complejo temp = {c.a, c.b};" ya que sino, se elimina al finalizar la funcion y devuelve basura en lugar de los valores deseados.

Steven R. Davidson
2013-05-17 07:58:46

Hola Rodrigo,

Es cierto que el objeto 'temp' es destruido al finalizar la función, pero no es cierto que se retorne basura.

Lo que sucede es que se pasa el objeto por copia, y por lo tanto, se instancia un nuevo objeto, invocando su constructor copia basado en 'temp'. Si lo prefieres, las sentencias que se ejecutan son:

complejo temp = {c.a, c.b};
c.a++;
complejo __retorno__( temp );  // return temp;

Recuerda que por defecto los datos se pasan por copia (o por valor), tanto para los parámetros de una función como para el retorno de una función.

Espero que esto aclare la duda.

Steven

Milton Parra
2014-02-07 21:36:01

No entiendo como el compilador diferencia el operador ++ pre-incremento y post-incremento en su ejemplo de sobrecarga de operadores porque, si bien es cierto que hay una definición para cada uno, al momento de invocarlos no veo diferencia. Gracias si pueden ampliarme esta explicación.

Steven R. Davidson
2014-02-07 23:09:28

Hola Milton,

La diferencia está en la colocación del operador:

z++;

Es un postincremento, porque el operador es sufijo: está detrás de la variable. Esto es equivalente a escribir:

operator++( z, 0 );

Hace falta pasar algún entero, pero da igual su valor, porque no se usará.

++z;

Es un preincremento, porque el operador es prefijo: está delante de la variable. Esto es equivalente a escribir:

operator++( z );

Recuerda que los operadores de preincremento y de postincremento siguen las mismas reglas del lenguaje; por ejemplo,

int a = 10;

a++;
++a;

El compilador saber cuál es cuál por la posición del operador con respecto al operando. Esto no cambia en la sobrecarga del operador; lo único que cambia es el comportamiento o la funcionalidad.

Espero haber aclarado la duda.

Steven

glendys leon
2014-05-28 02:11:05

hola tengo un ejercicio donde tengo que agrear los operadores

fecha //esta es mi clase

fecha operator +( int);

void operator ++( int);

fecha operator +( fecha);

void operator --( int);

void operator ==( fechas);

fecha operator >( fechas);

fecha operator <( fechas);

es parecido al ejemplo fecha que tienes de ultimo pero no se hacer mas nada porfa ayudame

Carlos Gonzalez Rubio
2014-07-30 22:10:40

como sobrecargar el operador << para poder obtener la salida de una suma de dos clases. EJEMPLO "cout << a + b << endl"

// valido :)

int main() {

Fraction a = "3/4";

Fraction b = "1/4";

Fraction c = a + b;

cout << c << endl;

return 0;

}

// invalido :(

int main() {

Fraction a = "3/4";

Fraction b = "1/4";

cout << a + b << endl;

return 0;

}

Mensaje del compilador:

error: cannot bind 'std::ostream {aka std::basic_ostream<char>}' lvalue to 'std::basic_ostream<char>&&'

cout << a + b << endl;

Steven R. Davidson
2014-08-01 14:58:39

Hola Carlos,

Para el ejemplo que muestras, una implementación sencilla puede ser:

struct Fraction
{
  int num, denom;
  ...
};

ostream & operator<<( ostream &os, const Fraction &ref )
{
  return os << ref.num << '/' << ref.denom;
}

No hubo errores durante la compilación y la ejecución es correcta.

Por el mensaje de error que recibes, sospecho que el problema se basa en que la clase que usas realmente es una plantilla. Por la razón que sea, el compilador no puede deducir el tipo de dato con la información dada cuando uses el operador <<. Tendrás que reescribir el diseño para que sea más fácil para el compilador determinar el tipo de dato de los parámetros del operador << sobrecargado.

Espero que esto te oriente.

Steven

Adri
2015-01-03 04:58:02

¿Soy el unico al que no le funciona ninguno de los ejemplos que contienen el "operator"?Y eso que he tenido en cuenta que donde pone <i> hay que eliminarlo porque debe ser un fallo de la pagina web.

Esto es lo que pogo para cada ejemplo:

#include <iostream>
using namespace std;
int main()
{/* 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; 
}
	return 0;
}
#include <iostream>
using namespace std;
int main()
{
	/* Definición del operador ++ prefijo para complejos */
complejo operator ++(complejo &c)  { 
   c.a++; 
   return c; 
}
	return 0;
}
#include <iostream>
using namespace std;
int main()
{
	/* Definición del operador ++ sufijo para complejos */
complejo operator ++(complejo &c, int)  { 
   complejo temp = {c.a, c.b};
   c.a++; 
   return temp; 
}
	return 0;
}
// Sobrecarga de operadores
// (C) 2009 Con Clase
// Salvador Pozo

#include <iostream>
using namespace std /*Aqui en realidad ponía <i>std</i>*/;
 
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; 
}

Estos son los errores que me lanza respectivamente:

C:\Users\Usuario\Desktop\SinNombre1.cpp	In function 'int main()':
5	1	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] 'complejo' was not declared in this scope
5	10	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] expected ';' before 'operator'
21	1	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] expected '}' at end of input
C:\Users\Usuario\Desktop\SinNombre1.cpp	In function 'int main()':
6	1	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] 'complejo' was not declared in this scope
6	10	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] expected ';' before 'operator'
C:\Users\Usuario\Desktop\SinNombre1.cpp	In function 'int main()':
6	1	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] 'complejo' was not declared in this scope
6	10	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] expected ';' before 'operator'
12	1	C:\Users\4Usuario\Desktop\SinNombre1.cpp	[Error] expected '}' at end of input
C:\Users\Usuario\Desktop\SinNombre1.cpp	In function 'int main()':
6	1	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] 'complejo' was not declared in this scope
6	10	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] expected ';' before 'operator'
12	1	C:\Users\Usuario\Desktop\SinNombre1.cpp	[Error] expected '}' at end of input

En los demás ejemplos no hay problema,ya que,de hecho, no usas el operador "operator"

He buscado ejemplos en otras paginas, pero casi todas usan class, cosa que todavia no he visto D-:

He supuesto que habia que crear previamente una estructura de tipo complejo, pero no va

Adri
2015-01-03 16:11:26

Perdon, creo que mejor debi enviar el mensaje anterior por correo.

Me acabo de dar cuenta ahora D=

Steven R. Davidson
2015-01-05 01:10:38

Hola Adri,

Los tres primeros códigos fuente tienen varios errores:

- Usas 'complejo' antes de definir tal entidad.

- Defines varias funciones (sobrecarga de operadores) dentro de la definición de la función, 'main()'; debes definirlas fuera.

El problema es que el primer ejemplo de este capítulo no está completo; se trata de un ejemplo parcial.

El último código fuente sí funciona, porque se trata del ejemplo completo mostrado en el capítulo.

Hasta pronto,

Steven

Enrique Sardon
2016-12-05 01:06:20

Hola, antes que nada, me encata su trabajo es increible la forma de enseñar c++ con este curso

Ahora a lo que vine esta web no se puede ver desde Peru, existe desde hace mucho tiempo y antes si se podía pero parece que hay un bloqueo a las direcciones de peru o es por parte del ISP, por favor si es por parte de ustedes, pueden desbloquear esta web? he aprendeido mucho con ella, pero ahora solo puedo acceder aqui mediante proxy o por tor...