Introduction à la surcharge d'opérateurs

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

La surcharge d'opérateurs vous permet de définir comment les opérateurs tels que +, -, ou == se comportent lorsqu'ils sont utilisés avec vos classes personnalisées. Au lieu d'appeler des méthodes comme a.add(b), vous pouvez écrire le plus intuitif a + b.

En C++, les opérateurs sont essentiellement des fonctions avec des noms spéciaux. Pour surcharger un opérateur, vous définissez une fonction en utilisant le mot-clé operator suivi du symbole :

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Surcharger l'opérateur +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Maintenant, vous pouvez additionner deux vecteurs naturellement :

Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;    // Appelle v1.operator+(v2)

Tous les opérateurs ne peuvent pas être surchargés. L'opérateur de résolution de portée ::, l'accès aux membres ., l'opérateur ternaire ?: et sizeof ne peuvent pas être surchargés. De plus, vous ne pouvez pas créer de nouveaux opérateurs ni modifier la priorité d'un opérateur - * sera toujours évalué avant +.

Les opérateurs peuvent être implémentés en tant que fonctions membres (comme ci-dessus) ou en tant que fonctions non-membres. Dans les prochaines leçons, vous apprendrez quand utiliser chaque approche et comment surcharger des catégories spécifiques d'opérateurs.

Défi

Facile

Construisons une classe Point qui représente une coordonnée 2D et permet d'additionner deux points à l'aide de l'opérateur +. C'est votre premier pas dans la surcharge d'opérateurs — faire en sorte que vos classes personnalisées fonctionnent avec des opérateurs familiers.

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

Point.h : Définissez une classe Point qui stocke les coordonnées x et y (toutes deux de type int). Votre classe doit avoir :
- Des membres privés pour les coordonnées x et y
- Un constructeur qui prend les valeurs x et y
- Des accesseurs (getters) getX() et getY() (tous deux const)
- Un opérateur + surchargé qui additionne deux points et renvoie un nouveau Point avec les coordonnées combinées
L'opérateur + doit être implémenté comme une fonction membre qui prend un autre Point par référence constante et renvoie un nouveau Point. Marquez-le comme const puisqu'il ne modifie aucun des opérandes.
main.cpp : Lisez quatre entiers à partir de l'entrée (x1, y1, x2, y2 sur des lignes séparées) représentant deux points. Créez deux objets Point, additionnez-les à l'aide de l'opérateur + et affichez les résultats.
Format de sortie :
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

L'idée clé ici est que p1 + p2 appelle en réalité p1.operator+(p2) en coulisses. Votre opérateur surchargé vous permet d'écrire du code intuitif comme Point p3 = p1 + p2; au lieu de quelque chose comme Point p3 = p1.add(p2);.

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

Aide-mémoire

La surcharge d'opérateurs vous permet de définir comment les opérateurs tels que +, - ou == se comportent avec des classes personnalisées, permettant une syntaxe intuitive comme a + b au lieu de a.add(b).

Pour surcharger un opérateur, définissez une fonction en utilisant le mot-clé operator suivi du symbole :

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Surcharger l'opérateur +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Utilisation :

Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;    // Appelle v1.operator+(v2)

Certains opérateurs ne peuvent pas être surchargés : ::, ., ?: et sizeof. Vous ne pouvez pas créer de nouveaux opérateurs ni modifier la priorité des opérateurs.

Les opérateurs peuvent être implémentés en tant que fonctions membres ou fonctions non-membres.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire l'entrée
    string line1, line2, line3, line4;
    getline(cin, line1);
    getline(cin, line2);
    getline(cin, line3);
    getline(cin, line4);

    int x1 = stoi(line1);
    int y1 = stoi(line2);
    int x2 = stoi(line3);
    int y2 = stoi(line4);

    // TODO: Créer deux objets Point en utilisant les valeurs d'entrée

    // TODO: Additionner les deux points ensemble en utilisant l'opérateur +

    // TODO: Afficher les résultats au format requis :
    // Point 1: (<x1>, <y1>)
    // Point 2: (<x2>, <y2>)
    // Sum: (<sum_x>, <sum_y>)

    return 0;
}