Introduction à la surcharge des 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 le comportement d’opérateurs tels que +, - ou == lorsqu’ils sont utilisés avec vos classes personnalisées. Au lieu d’appeler des méthodes comme a.add(b), vous pouvez écrire l’expression plus intuitive a + b.

En C++, les opérateurs sont essentiellement des fonctions portant des noms spéciaux. Pour surcharger un opérateur, vous définissez une fonction à l’aide du 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);
    }
};

Vous pouvez maintenant Add 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 comme des fonctions membres (comme ci-dessus) ou comme des fonctions non membres. Dans les prochaines leçons, tu apprendras 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 +. Il s’agit de votre première étape vers la surcharge d’opérateurs, qui permet à vos classes personnalisées de fonctionner avec des opérateurs familiers.

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

Point.h : Définir une classe Point qui stocke les coordonnées x et y (toutes deux de type int). Votre classe doit comporter :
- Des membres privés pour les coordonnées x et y
- Un constructeur qui prend les valeurs x et y
- Les accesseurs 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 deux opérandes.
main.cpp : Lire quatre entiers depuis l’entrée (x1, y1, x2, y2 sur des lignes séparées) représentant deux points. Créer deux objets Point, les additionner à l’aide de l’opérateur +, puis afficher les résultats.
Format de sortie :
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

L’idée essentielle ici est que p1 + p2 appelle en réalité p1.operator+(p2) en arrière-plan. 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 dans votre fichier d’en-tête.

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: Ajouter les deux points ensemble en utilisant l'opérateur +

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

    return 0;
}