Sobrecarga de operadores aritméticos

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 41 de 104.

Los operadores aritméticos como +, -, * y / suelen sobrecargarse para hacer que las clases personalizadas se comporten como tipos numéricos integrados. Estos operadores normalmente devuelven un objeto nuevo en lugar de modificar los operandos.

Aquí tienes una clase Fraction con operadores aritméticos:

class Fraction {
    int numerator, denominator;
    
public:
    Fraction(int n, int d) : numerator(n), denominator(d) {}
    
    Fraction operator+(const Fraction& other) const {
        return Fraction(
            numerator * other.denominator + other.numerator * denominator,
            denominator * other.denominator
        );
    }
    
    Fraction operator*(const Fraction& other) const {
        return Fraction(numerator * other.numerator, 
                        denominator * other.denominator);
    }
};

Observa que ambos operadores están marcados como const porque no modifican ninguno de los operandos. Crean y devuelven una nueva Fraction con el resultado.

Para operadores de asignación compuesta como +=, el patrón es diferente. Estos modifican el operando izquierdo y devuelven una referencia a él:

Fraction& operator+=(const Fraction& other) {
    numerator = numerator * other.denominator + other.numerator * denominator;
    denominator = denominator * other.denominator;
    return *this;
}

Una práctica común es implementar el operador básico en términos de la asignación compuesta, reduciendo la duplicación de código:

Fraction operator+(const Fraction& other) const {
    Fraction result = *this;    // Copia este objeto
    result += other;            // Usa la asignación compuesta
    return result;
}

Este enfoque garantiza que ambos operadores se mantengan coherentes y facilita el mantenimiento.

Desafío

Fácil

Construyamos una clase Money que gestione cálculos monetarios mediante la sobrecarga de operadores aritméticos. Implementarás varios operadores aritméticos que te permitirán trabajar con valores monetarios de forma tan natural como con números normales.

Crearás dos archivos para organizar tu código:

Money.h: Define una clase Money que almacene una cantidad en centavos (como un int) para evitar problemas de precisión de coma flotante. Tu clase debe admitir:
- Un constructor que reciba los dólares y los centavos como enteros separados
- Un getter getDollars() que devuelva la parte correspondiente a los dólares
- Un getter getCents() que devuelva la parte correspondiente a los centavos (0-99)
- Operadores + y - sobrecargados que devuelvan un nuevo objeto Money
- Operadores de asignación compuesta += y -= sobrecargados que modifiquen el objeto actual y devuelvan una referencia a él
- Un método display() que muestre el dinero con el formato $X.YY (siempre dos dígitos para los centavos)
Implementa los operadores básicos (+ y -) en términos de los operadores de asignación compuesta para reducir la duplicación de código, como se muestra en la lección. Todos los operadores aritméticos deben marcarse como const cuando corresponda.
main.cpp: Lee cuatro enteros de la entrada que representen dos cantidades monetarias (dollars1, cents1, dollars2, cents2 en líneas separadas). Crea dos objetos Money y, después, demuestra todos tus operadores:
- Imprime "Amount 1: " seguido de la primera cantidad mostrada
- Imprime "Amount 2: " seguido de la segunda cantidad mostrada
- Suma las dos cantidades e imprime "Sum: " seguido del resultado
- Resta la segunda cantidad de la primera e imprime "Difference: " seguido del resultado
- Usa += para sumar la segunda cantidad a la primera y, después, imprime "After +=: " seguido de la primera cantidad modificada

Para el método display(), usa std::setw(2) y std::setfill('0') de <iomanip> para garantizar que los centavos siempre se muestren con dos dígitos (por ejemplo, $5.07 en lugar de $5.7).

Convierte las cadenas de entrada en enteros usando std::stoi(). No olvides las protecciones contra inclusiones múltiples en tu archivo de cabecera.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Money.h"

using namespace std;

int main() {
    // Lee la entrada de dos cantidades de dinero
    string line;
    
    getline(cin, line);
    int dollars1 = stoi(line);
    
    getline(cin, line);
    int cents1 = stoi(line);
    
    getline(cin, line);
    int dollars2 = stoi(line);
    
    getline(cin, line);
    int cents2 = stoi(line);
    
    // TODO: Crea dos objetos Money con los valores de entrada
    
    // TODO: Imprime "Amount 1: " seguido de la primera cantidad mostrada
    
    // TODO: Imprime "Amount 2: " seguido de la segunda cantidad mostrada
    
    // TODO: Suma las dos cantidades e imprime "Sum: " seguido del resultado
    
    // TODO: Resta la segunda de la primera e imprime "Difference: " seguido del resultado
    
    // TODO: Usa += para sumar la segunda cantidad a la primera, luego imprime "After +=: " seguido de la primera cantidad modificada
    
    return 0;
}