Opérateurs de flux

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

Les opérateurs d'insertion (<<) et d'extraction (>>) de flux vous permettent d'utiliser vos classes personnalisées avec std::cout et std::cin. Contrairement aux opérateurs que nous avons vus jusqu'à présent, ceux-ci doivent être implémentés en tant que fonctions non membres car l'opérande de gauche est un flux, et non votre classe.

class Point {
    int x, y;
    
public:
    Point(int x, int y) : x(x), y(y) {}
    
    // Déclarer comme amie pour accéder aux membres privés
    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;
}

Les deux opérateurs retournent une référence au flux, permettant le chaînage comme std::cout << p1 << p2. L'opérateur d'insertion prend l'objet par référence const puisqu'il lit seulement les données, tandis que l'extraction prend une référence non-const car elle modifie l'objet.

Maintenant, vous pouvez utiliser Point naturellement avec les flux :

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

Point p2(0, 0);
std::cin >> p2;    // Lire deux entiers dans p2

Défi

Facile

Construisons une classe Temperature qui peut être utilisée de manière transparente avec std::cout et std::cin grâce à la surcharge des opérateurs de flux. Il s'agit d'un scénario pratique où vous souhaitez afficher des températures dans un format lisible et les lire naturellement à partir de l'entrée.

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

Temperature.h : Définissez une classe Temperature qui stocke une valeur de température (sous forme de double) et un symbole d'unité (sous forme de char, soit 'C' pour Celsius ou 'F' pour Fahrenheit). Votre classe doit comporter :
- Des membres privés pour la valeur de la température et l'unité
- Un constructeur par défaut qui initialise à 0.0 Celsius
- Un constructeur paramétré qui prend une valeur et une unité
- Des accesseurs getValue() et getUnit() (tous deux const)
- Des déclarations d'amitié (friend) pour les opérateurs d'insertion (<<) et d'extraction (>>) de flux
Implémentez les opérateurs de flux en tant que fonctions non-membres :
- L'opérateur d'insertion doit afficher la température au format VALUE UNIT (par exemple, 25.5 C ou 77.9 F). Utilisez une décimale pour la valeur.
- L'opérateur d'extraction doit lire une valeur et un caractère d'unité à partir du flux et les stocker dans l'objet Temperature.
Les deux opérateurs doivent retourner une référence au flux pour permettre le chaînage.
main.cpp : Lisez deux températures à partir de l'entrée. Chaque température est fournie sur une ligne séparée au format value unit (par exemple, 25.5 C).
Créez deux objets Temperature en utilisant l'opérateur d'extraction pour les lire depuis std::cin. Ensuite, affichez-les en utilisant l'opérateur d'insertion dans ce format :
```
Temperature 1: <temp1>
Temperature 2: <temp2>
```
Par exemple, si l'entrée est :
```
25.5 C
98.6 F
```
La sortie doit être :
```
Temperature 1: 25.5 C
Temperature 2: 98.6 F
```

Utilisez std::fixed et std::setprecision(1) de <iomanip> pour formater la valeur de la température avec exactement une décimale. N'oubliez pas les gardes d'inclusion (header guards) dans votre fichier d'en-tête.

Essayez vous-même

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

int main() {
    // TODO: Créer deux objets Temperature
    
    // TODO: Utiliser l'opérateur d'extraction (>>) pour lire deux températures depuis std::cin
    
    // TODO: Afficher les températures en utilisant l'opérateur d'insertion (<<)
    // Format :
    // Temperature 1: <temp1>
    // Temperature 2: <temp2>
    
    return 0;
}