Surcharge des opérateurs arithmétiques

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 41 sur 104.

Les opérateurs arithmétiques tels que +, -, * et / sont généralement surchargés afin que les classes personnalisées se comportent comme des types numériques intégrés. Ces opérateurs renvoient généralement un nouvel objet plutôt que de modifier les opérandes.

Voici une classe Fraction avec des opérateurs arithmétiques :

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);
    }
};

Note que les deux opérateurs sont marqués const puisqu’ils ne modifient aucun des deux opérandes. Ils créent et renvoient une nouvelle Fraction contenant le résultat.

Pour les opérateurs d’affectation composés comme +=, le modèle est différent. Ceux-ci modifient l’opérande de gauche et renvoient une référence à celui-ci :

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

Une pratique courante consiste à implémenter l’opérateur de base en fonction de l’assignment composé, afin de réduire la duplication de code :

Fraction operator+(const Fraction& other) const {
    Fraction result = *this;    // Copier cet objet
    result += other;            // Utiliser l'affectation composée
    return result;
}

Cette approche garantit que les deux opérateurs restent cohérents et facilite la maintenance.

Défi

Facile

Construisons une classe Money qui gère les calculs monétaires à l'aide de la surcharge des opérateurs arithmétiques. Vous implémenterez plusieurs opérateurs arithmétiques qui vous permettront de manipuler des valeurs monétaires aussi naturellement que des nombres ordinaires.

Vous allez créer deux fichiers pour organiser votre code :

Money.h : Define une classe Money qui stocke un amount en cents (sous forme de int) afin d'avoid les problèmes de précision liés aux nombres à virgule floating. Votre classe doit prendre en charge :
- Un Constructor qui prend dollars et cents comme entiers séparés
- Un accesseur getDollars() qui renvoie la partie en dollars
- Un accesseur getCents() qui renvoie la partie en cents (0-99)
- Les opérateurs + et - surchargés, qui renvoient un nouvel objet Money
- Les opérateurs d'assignation compound += et -= surchargés, qui modifient l'objet current et renvoient une référence vers celui-ci
- Une méthode display() qui affiche l'argent au format $X.YY (toujours deux chiffres pour les cents)
Implement les opérateurs de base (+ et -) en termes des opérateurs d'assignation compound afin de réduire la duplication de code, comme indiqué dans la leçon. Tous les opérateurs arithmétiques doivent être marqués const lorsque cela est approprié.
main.cpp : Lisez quatre entiers depuis l'input représentant deux amounts monétaires (dollars1, cents1, dollars2, cents2 sur des lignes distinctes). Créez deux objets Money, puis démontrez tous vos opérateurs :
- Affichez "Amount 1: " followed de l'amount first displayed
- Affichez "Amount 2: " followed du second amount displayed
- Add les deux amounts et affichez "Sum: " followed du résultat
- Soustrayez le second du first et affichez "Difference: " followed du résultat
- Utilisez += pour add le second amount au first, puis affichez "After +=: " followed du first amount modifié

Pour la méthode display(), utilisez std::setw(2) et std::setfill('0') de <iomanip> afin de garantir que les cents s'affichent toujours avec deux chiffres (par exemple, $5.07 et non $5.7).

Convertissez les chaînes d'input en entiers à l'aide de std::stoi(). N'oubliez pas les header guards dans votre fichier d'en-tête.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire les entrées pour deux montants d'argent
    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: Créer deux objets Money avec les valeurs d'entrée
    
    // TODO: Afficher "Amount 1: " suivi du premier montant affiché
    
    // TODO: Afficher "Amount 2: " suivi du second montant affiché
    
    // TODO: Ajouter les deux montants et afficher "Sum: " suivi du résultat
    
    // TODO: Soustraire le second du premier et afficher "Difference: " suivi du résultat
    
    // TODO: Utiliser += pour ajouter le second montant au premier, puis afficher "After +=: " suivi du premier montant modifié
    
    return 0;
}