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 {cc:035#inicio: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 {cc:035#inicio: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;
    };
    

Ejemplos capítulo 22

Ejemplo 22.1

Vamos a ver con qué tipo de objetos podemos hacer operaciones.

Lo principal, a la hora de operarar con cualquier tipo de objeto, es definir claramente cada operación.

Esta definición incluye el número y tipo de cada operando, el tipo del resultado y el modo en que se combinan los operandos para obtener el resultado.

En este ejemplo sumaremos dos arrays de enteros. La primera condición afecta a los parámetros y valor de retorno, e implica que sumaremos dos arrays y el resultado será un array.

Podemos restringir la operación, de modo que sólo sea posible sumar arrays del mismo tamaño, es decir, con el mísmo número de elementos, de forma que se sumen los elementos en la misma posición, y el resultado sea un array del mismo tamaño.

También podemos hacer que se puedan sumar arrays de diferente longitud, de modo que se sumen los elementos que existan en los dos arrays. Para el resto de los elementos tenemos dos opciones, una es sumarlos con cero, de modo que el array de salida tenga tantos elementos como el mayor de los de entrada. La otra opción es ignorar los sobrantes, de modo que el array de salida tenga tantos elementos como el menor de los de entrada.

Otra posibilidad es que la suma de dos array sea un tercer array con los elementos de ambos. Es decir, si sumamos dos arrays de 4 y 8 elementos, el resultado será un array con 12 elementos, que contendrá los elementos de los dos iniciales.

Para este ejemplo tomaremos la primera opción. Cuando los arrays sean de diferente tamaño, retornaremos un array nulo, es decir, vacío.

// Suma de arrays
// (C) 2009 Con Clase
// Salvador Pozo

#include <iostream>
using namespace std;

struct array {
    int *v; // Elementos
    int n;  // Número de elementos
};

array operator +(array, array);
void Mostrar(array);

int main() {
    array v1, v2, v3;

    v1.n = v2.n = 10;
    v1.v = new int[v1.n];
    v2.v = new int[v2.n];

    for(int i = 0; i < 10; i++) {
        v1.v[i] = i;
        v2.v[i] = 2*i-4;
    }
    v3 = v1 + v2;

    cout << "v1: ";
    Mostrar(v1);
    cout << "v2: ";
    Mostrar(v2);
    cout << "v3 = v1+v2: ";
    Mostrar(v3);

    delete[] v1.v;
    delete[] v2.v;
    delete[] v3.v;
    return 0;
}

array operator +(array a, array b) {
    array temp;

    if(a.n == b.n) {
        temp.n = a.n;
        temp.v = new int[temp.n];
        for(int i = 0; i < temp.n; i++) temp.v[i] = a.v[i]+b.v[i];
    } else {
        temp.v = 0;
        temp.n = 0;
    }
    return temp;
}

void Mostrar(array v) {
    for(int i = 0; i < v.n; i++) {
        cout << v.v[i] << ((i < v.n-1) ? "," : "");
    }
    cout << endl;
}

Ejecutar este código en codepad.

Hay que tener cuidado con esta forma de trabajar. Hay un peligro en el uso del operador de asignación con estructuras que contengan punteros y memoria dinámica, que es el que comentamos antes. El compilador crea un operador por defecto, pero no se preocupa de las posibles fugas de memoria.

Si en este ejemplo usamos una expresión de suma, asignando el resultado a un objeto que previamente tenía un valor válido, el valor previo se pierde, y será imposible acceder a él ya sea para trabajar con él o para liberar la memoria utilizada.

Otro peligro es usar estas expresiones sin asignar el valor a ningún objeto, por ejemplo:

    cout << "v1+v2: ";
    Mostrar(v1+v2);

En este caso, tampoco podremos liberar la memoria asignada al objeto temporal.

La sobrecarga de operadores fuera de las clases es imperfecta. Tendremos que ser muy cuidadosos si la usamos.

Veremos un mejor uso más adelante.

Ejemplo 22.2

Sobrecargar operadores para objetos con memoria dinámica no es práctico, veremos que es mejor usar clases para eso.

Ahora vamos a sumar un número de días a una fecha. En este caso, el primer argumento es una fecha y el segundo un entero, que indica el número de días.

Se trata de un ejemplo, en un caso real creo que sería más intuitivo usar una función para este propósito, ya que una de las reglas de la suma es que no se deben sumar objetos de distinto tipo, ya sabes, no se pueden sumar peras y manzanas...

La aritmética de fechas es parecida a la aritmética de punteros, se pueden restar fechas, con lo que se obtiene un entero, y se pueden sumar enteros a fechas, con lo que se obtiene una fecha.

// Suma de fechas
// (C) 2009 Con Clase
// Salvador Pozo

#include <iostream>
using namespace std;

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

fecha operator +(fecha, int);
bool bisiesto(int);

int main() {
    fecha f1 = { 12, 11, 2009 };
    fecha f2;

    f2 = f1 + 1485;

    cout << "fecha 1: " << f1.dia << "/" << f1.mes << "/" << f1.anno << endl;
    cout << "fecha 2: " << f2.dia << "/" << f2.mes << "/" << f2.anno << endl;
    return 0;
}

fecha operator +(fecha f1, int d) {
    int dm[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    fecha temp = f1;

    temp.dia += d;
    if(bisiesto(temp.anno)) dm[1] = 29; else dm[1] = 28;
    while(temp.dia > dm[temp.mes-1]) {
        temp.dia -= dm[temp.mes-1];
        temp.mes++;
        if(temp.mes > 12) {
            temp.mes = 1;
            temp.anno++;
            if(bisiesto(temp.anno)) dm[1] = 29; else dm[1] = 28;
        }
    }

    return temp;
}

bool bisiesto(int a) {
    return !(a%4) && ((a%100) || !(a%400));
}

Ejecutar este código en codepad.