Operatori di flusso

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

Gli operatori di inserimento nel flusso (<<) ed estrazione dal flusso (>>) ti permettono di usare le tue classi personalizzate con std::cout e std::cin. A differenza degli operatori trattati finora, questi devono essere implementati come funzioni non membro, perché l'operando a sinistra è un flusso, non la tua classe.

class Point {
    int x, y;
    
public:
    Point(int x, int y) : x(x), y(y) {}
    
    // Dichiara come friend per accedere ai membri privati
    friend std::ostream& operator<<(std::ostream& os, const Point& p);
    friend std::istream& operator>>(std::istream& is, Point& p);
};

std::ostream& operator<<(std::ostream& os, const Point& p) {
    os << "(" << p.x << ", " << p.y << ")";
    return os;
}

std::istream& operator>>(std::istream& is, Point& p) {
    is >> p.x >> p.y;
    return is;
}

Entrambi gli operatori restituiscono un riferimento allo stream, consentendo concatenazioni come std::cout << p1 << p2. L'operatore di inserimento prende l'oggetto per riferimento const perché legge soltanto i dati, mentre l'operatore di estrazione prende un riferimento non const perché modifica l'oggetto.

Ora puoi usare Point naturalmente con gli stream:

Point p(3, 4);
std::cout << "Location: " << p << std::endl;    // Risultato: Location: (3, 4)

Point p2(0, 0);
std::cin >> p2;    // Leggi due numeri interi in p2

Sfida

Facile

Creiamo una classe Temperature che possa essere usata senza problemi con std::cout e std::cin tramite l'overload degli operatori di flusso. Questo è uno scenario pratico in cui vuoi visualizzare le temperature in un formato leggibile e leggerle dall'input in modo naturale.

Creerai due file per organizzare il codice:

Temperature.h: definisci una classe Temperature che memorizza un valore di temperatura (come double) e un'etichetta dell'unità (come char, 'C' per Celsius oppure 'F' per Fahrenheit). La classe deve avere:
- membri privati per il valore della temperatura e l'unità
- un costruttore predefinito che inizializza il valore a 0.0 gradi Celsius
- un costruttore con parametri che accetta un valore e un'unità
- i getter getValue() e getUnit() (entrambi const)
- dichiarazioni friend per gli operatori di inserimento (<<) ed estrazione (>>) del flusso
Implementa gli operatori di flusso come funzioni non membro:
- L'operatore di inserimento deve visualizzare la temperatura nel formato VALUE UNIT (ad esempio, 25.5 C o 77.9 F). Usa una cifra decimale per il valore.
- L'operatore di estrazione deve leggere un valore e un carattere che indica l'unità dal flusso e memorizzarli nell'oggetto Temperature.
Entrambi gli operatori devono restituire un riferimento al flusso per consentire il concatenamento.
main.cpp: leggi due temperature dall'input. Ogni temperatura è fornita su una riga separata nel formato value unit (ad esempio, 25.5 C).
Crea due oggetti Temperature usando l'operatore di estrazione per leggerli da std::cin. Poi visualizzali usando l'operatore di inserimento in questo formato:
```
Temperature 1: <temp1>
Temperature 2: <temp2>
```
Per esempio, se l'input è:
```
25.5 C
98.6 F
```
L'output dovrebbe essere:
```
Temperature 1: 25.5 C
Temperature 2: 98.6 F
```

Usa std::fixed e std::setprecision(1) da <iomanip> per formattare il valore della temperatura con esattamente una cifra decimale. Non dimenticare le protezioni dell'header nel file header.

Provalo tu

#include <iostream>
#include "Temperature.h"

int main() {
    // TODO: Crea due oggetti Temperature
    
    // TODO: Usa l'operatore di estrazione (>>) per leggere due temperature da std::cin
    
    // TODO: Visualizza le temperature usando l'operatore di inserimento (<<)
    // Formato:
    // Temperature 1: <temp1>
    // Temperature 2: <temp2>
    
    return 0;
}