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.