Sobrecarga de Operadores Aritméticos

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 41 de 104.

Operadores aritméticos como +, -, * e / geralmente são sobrecarregados para fazer com que classes personalizadas se comportem como tipos numéricos integrados. Esses operadores normalmente retornam um novo objeto em vez de modificar os operandos.

Aqui está uma classe Fraction com 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);
    }
};

Observe que ambos os operadores são marcados como const, pois não modificam nenhum dos operandos. Eles criam e retornam uma nova Fraction com o resultado.

Para operadores de atribuição composta como +=, o padrão é diferente. Eles modificam o operando à esquerda e retornam uma referência a ele:

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

Uma prática comum é implementar o operador básico em termos da atribuição compound, reduzindo a duplication de código:

Fraction operator+(const Fraction& other) const {
    Fraction result = *this;    // Copia este objeto
    result += other;            // Usa a atribuição composta
    return result;
}

Essa abordagem garante que ambos os operadores permaneçam consistentes e facilita a manutenção.

Desafio

Fácil

Vamos criar uma classe Money que lida com cálculos monetários usando sobrecarga de operadores aritméticos. Você implementará vários operadores aritméticos que permitirão trabalhar com valores monetários tão naturalmente quanto com números comuns.

Você criará dois arquivos para organizar seu código:

Money.h: defina uma classe Money que armazene um amount em cents (como um int) para avoid problemas de precisão de ponto flutuante. Sua classe deve oferecer suporte a:
- Um Constructor que receba dollars e cents como inteiros separados
- Um getter getDollars() que retorne a parte em dollars
- Um getter getCents() que retorne a parte em cents (0-99)
- Operadores + e - sobrecarregados que retornem um novo objeto Money
- Operadores de atribuição compound += e -= sobrecarregados que modifiquem o objeto current e retornem uma referência a ele
- Um método display() que mostre o dinheiro no format $X.YY (sempre dois dígitos para cents)
Implement os operadores básicos (+ e -) usando os operadores de atribuição compound para reduzir a duplication de código, conforme mostrado na lição. Todos os operadores aritméticos devem ser marcados como const quando apropriado.
main.cpp: leia quatro inteiros do input representando dois amounts monetários (dollars1, cents1, dollars2, cents2 em linhas separadas). Crie dois objetos Money e, em seguida, demonstre todos os seus operadores:
- Mostre "Amount 1: " followed by o first amount exibido
- Mostre "Amount 2: " followed by o segundo amount exibido
- Adicione os dois amounts e mostre "Sum: " followed by o resultado
- Subtraia o segundo do first e mostre "Difference: " followed by o resultado
- Use += para adicionar o segundo amount ao first e, em seguida, mostre "After +=: " followed by o first amount modificado

Para o método display(), use std::setw(2) e std::setfill('0') de <iomanip> para garantir que cents sempre sejam exibidos com dois dígitos (por exemplo, $5.07, e não $5.7).

Converta as strings de input em inteiros usando std::stoi(). Não se esqueça dos protetores de cabeçalho no seu arquivo de cabeçalho.

Experimente você mesmo

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

using namespace std;

int main() {
    // Ler a entrada para duas quantias de dinheiro
    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: Criar dois objetos Money com os valores de entrada
    
    // TODO: Imprimir "Amount 1: " seguido pela primeira quantia exibida
    
    // TODO: Imprimir "Amount 2: " seguido pela segunda quantia exibida
    
    // TODO: Somar as duas quantias e imprimir "Sum: " seguido pelo resultado
    
    // TODO: Subtrair a segunda da primeira e imprimir "Difference: " seguido pelo resultado
    
    // TODO: Usar += para adicionar a segunda quantia à primeira e então imprimir "After +=: " seguido pela primeira quantia modificada
    
    return 0;
}