Introduzione al sovraccarico degli operatori

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 40 di 104.

L'overloading degli operatori ti permette di definire come si comportano operatori come +, - o == quando vengono usati con le tue classi personalizzate. Invece di chiamare metodi come a.add(b), puoi scrivere la forma più intuitiva a + b.

In C++, gli operatori sono essenzialmente funzioni con nomi speciali. Per sovraccaricare un operatore, definisci una funzione usando la parola chiave operator seguita dal simbolo:

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Sovraccarica l'operatore +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Ora puoi sommare due vettori in modo naturale:

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

Non tutti gli operatori possono essere sovraccaricati. L'operatore di risoluzione dell'ambito ::, l'accesso ai membri ., l'operatore ternario ?: e sizeof non possono essere sovraccaricati. Inoltre, non puoi creare nuovi operatori né modificare la precedenza di un operatore: * verrà sempre valutato prima di +.

Gli operatori possono essere implementati come funzioni membro (come sopra) o come funzioni non membro. Nelle prossime lezioni imparerai quando usare ciascun approccio e come sovraccaricare categorie specifiche di operatori.

Sfida

Facile

Creiamo una classe Point che rappresenta una coordinata 2D e supporta la somma di due punti usando l'operatore +. Questo è il tuo primo passo nell'overloading degli operatori, che permette alle tue classi personalizzate di funzionare con operatori familiari.

Creerai due file per organizzare il tuo codice:

Point.h: definisci una classe Point che memorizza le coordinate x e y (entrambe int). La tua classe dovrebbe avere:
- membri privati per le coordinate x e y
- un costruttore che accetta i valori di x e y
- getter getX() e getY() (entrambi const)
- un operatore + sovraccaricato che somma due punti e restituisce un nuovo Point con le coordinate combinate
L'operatore + dovrebbe essere implementato come funzione membro che accetta un altro Point per riferimento const e restituisce un nuovo Point. Contrassegnalo come const poiché non modifica nessuno dei due operandi.
main.cpp: leggi quattro numeri interi dall'input (x1, y1, x2, y2 su righe separate) che rappresentano due punti. Crea due oggetti Point, sommali usando l'operatore + e visualizza i risultati.
Formato dell'output:
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

L'idea fondamentale è che p1 + p2 in realtà richiama p1.operator+(p2) dietro le quinte. L'operatore sovraccaricato ti permette di scrivere codice intuitivo come Point p3 = p1 + p2; invece di qualcosa come Point p3 = p1.add(p2);.

Converti le stringhe di input in numeri interi usando std::stoi(). Non dimenticare le include guard nel tuo file header.

Provalo tu

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

using namespace std;

int main() {
    // Leggi l'input
    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: Crea due oggetti Point usando i valori di input

    // TODO: Somma i due punti usando l'operatore +

    // TODO: Mostra i risultati nel formato richiesto:
    // Punto 1: (<x1>, <y1>)
    // Punto 2: (<x2>, <y2>)
    // Somma: (<sum_x>, <sum_y>)

    return 0;
}