Surcharge des opérateurs en C++

En C++, la surcharge d’opérateurs (operator overloading) permet de redéfinir les opérateurs standards (+, ==, <, <<, etc.) pour des types de classes personnalisés. Grâce à cette fonctionnalité, les objets de classe peuvent se comporter comme des types intégrés (int, double, etc.). Dans cet article, nous allons étudier les opérateurs arithmétiques, de comparaison et de flux (stream) en les appliquant à la classe Book.

1. Qu’est-ce que la surcharge d’opérateurs ?

La surcharge d’opérateurs est utilisée pour définir un comportement personnalisé pour une classe. Par exemple, deux objets Book peuvent être additionnés avec + ou comparés avec ==.

Les fonctions d’opérateur se définissent comme des fonctions membres normales :

class NomDeClasse {
public:
    TypeDeRetour operator<Opérateur>(Paramètres) {
        // comportement personnalisé
    }
};

Par exemple, Book operator+(const Book& other) signifie que l’opérateur + est défini pour additionner deux objets Book.

2. Classe Book de base

La classe suivante représente un livre avec un titre, un prix et un nombre de pages. Nous l’utiliserons pour illustrer différentes surcharges d’opérateurs.

#include <iostream>
#include <string>
using namespace std;

class Book {
private:
    string title;
    double price;
    int pages;

public:
    Book(string t = "", double p = 0.0, int pg = 0)
        : title(t), price(p), pages(pg) {}

    void Show() const {
        cout << "Livre : " << title
             << " | Pages : " << pages
             << " | Prix : " << price << " €" << endl;
    }

    double GetPrice() const { return price; }
    int GetPages() const { return pages; }
    string GetTitle() const { return title; }
};

3. L’opérateur + (Combiner deux livres)

En additionnant deux livres avec +, on crée un nouveau livre « bundle ». Le prix total est la somme des prix et le nombre de pages la somme des pages.

Book operator+(const Book &other) const {
    string combinedTitle = title + " & " + other.title;
    double combinedPrice = price + other.price;
    int combinedPages = pages + other.pages;
    return Book(combinedTitle, combinedPrice, combinedPages);
}

Utilisation :

Book b1("C++ Primer", 180.0, 980);
Book b2("Effective C++", 150.0, 400);

Book combo = b1 + b2;
combo.Show();

Résultat :

Livre : C++ Primer & Effective C++
| Pages : 1380 | Prix : 330 €

4. L’opérateur == (Comparaison d’égalité)

Pour vérifier si deux livres sont identiques, on peut surcharger l’opérateur ==. Par exemple, s’ils ont le même titre, prix et nombre de pages, ils sont considérés comme égaux.

bool operator==(const Book &other) const {
    return (title == other.title &&
            pages == other.pages &&
            price == other.price);
}

Utilisation :

Book a("1984", 99.9, 328);
Book b("1984", 99.9, 328);

if (a == b)
    cout << "Les livres sont identiques." << endl;
else
    cout << "Les livres sont différents." << endl;

Résultat :

Les livres sont identiques.

5. L’opérateur < (Comparaison)

Pour comparer les livres selon leur prix, on peut surcharger l’opérateur <. Cet opérateur est notamment utilisé par std::sort() ou std::set.

bool operator<(const Book &other) const {
    return price < other.price;
}

Utilisation :

Book b1("C++ Primer", 180, 900);
Book b2("Clean Code", 220, 500);

if (b1 < b2)
    cout << b1.GetTitle() << " est moins cher." << endl;

Résultat :

C++ Primer est moins cher.

6. L’opérateur ++ (Incrémenter le nombre de pages)

L’opérateur ++ peut être défini sous deux formes : préfixe et postfixe. Dans cet exemple, il augmente le nombre de pages d’un livre.

// Préfixe (++livre)
Book& operator++() {
    ++pages;
    return *this;
}

// Postfixe (livre++)
Book operator++(int) {
    Book temp = *this;
    pages++;
    return temp;
}

Utilisation :

Book b("C++ 101", 120.0, 250);
++b;  // préfixe
b++;  // postfixe
b.Show(); // 252 pages

7. L’opérateur << (Affichage avec ostream)

Pour afficher un objet directement avec cout << b;, il faut surcharger globalement l’opérateur <<. Cet opérateur renvoie généralement une référence vers ostream.

friend ostream& operator<<(ostream &os, const Book &b) {
    os << "[Livre : " << b.title
       << ", Pages : " << b.pages
       << ", Prix : " << b.price << " €]";
    return os;
}

Utilisation :

Book b("Clean Architecture", 175.0, 350);
cout << b << endl;

Résultat :

[Livre : Clean Architecture, Pages : 350, Prix : 175 €]

8. Exemple complet : utilisation de tous les opérateurs

#include <iostream>
#include <string>
using namespace std;

class Book {
private:
    string title;
    double price;
    int pages;

public:
    Book(string t = "", double p = 0, int pg = 0)
        : title(t), price(p), pages(pg) {}

    Book operator+(const Book &other) const {
        return Book(title + " & " + other.title,
                    price + other.price,
                    pages + other.pages);
    }

    bool operator==(const Book &other) const {
        return (title == other.title && price == other.price);
    }

    bool operator<(const Book &other) const {
        return price < other.price;
    }

    Book& operator++() {
        ++pages;
        return *this;
    }

    Book operator++(int) {
        Book temp = *this;
        pages++;
        return temp;
    }

    friend ostream& operator<<(ostream &os, const Book &b) {
        os << b.title << " - " << b.price << " € (" << b.pages << " pages)";
        return os;
    }
};

int main() {
    Book b1("C++ Primer", 180.0, 900);
    Book b2("Effective C++", 150.0, 400);

    Book combo = b1 + b2;
    cout << combo << endl;

    ++combo;
    combo++;

    cout << "Après incrémentation : " << combo << endl;

    cout << (b1 < b2 ? "b1 est moins cher" : "b2 est moins cher") << endl;

    if (b1 == b2)
        cout << "Les livres sont identiques." << endl;
    else
        cout << "Les livres sont différents." << endl;
}

Résultat :

C++ Primer & Effective C++ - 330 € (1300 pages)
Après incrémentation : C++ Primer & Effective C++ - 330 € (1302 pages)
b1 est moins cher
Les livres sont différents.

9. TL;DR

Articles connexes