Menu
CoddyTech

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 que las clases personalizadas se comporten como los 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 habitual es implementar el operador básico mediante 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.

challenge icon

Desafío

Fácil

Vamos a crear 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 con la misma naturalidad que 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 punto flotante. Tu clase debe admitir:
    • Un constructor que reciba dólares y centavos como enteros separados
    • Un método getter getDollars() que devuelva la parte en dólares
    • Un método getter getCents() que devuelva la parte en centavos (0-99)
    • Los operadores sobrecargados + y -, que devuelvan un nuevo objeto Money
    • Los operadores de asignación compuesta sobrecargados += y -=, que modifiquen el objeto actual y devuelvan una referencia a él
    • Un método display() que imprima el dinero con el formato $X.YY (siempre con dos dígitos para los centavos)

    Implementa los operadores básicos (+ y -) a partir 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 de dinero (dollars1, cents1, dollars2, cents2 en líneas separadas). Crea dos objetos Money y luego 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 asegurarte de que los centavos siempre se muestren con dos dígitos (por ejemplo, $5.07 y no $5.7).

Convierte las cadenas de entrada a 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 los datos de entrada para 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 cantidad 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;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online