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 (>>) des flux vous permettent d’utiliser vos classes personnalisées avec std::cout et std::cin. Contrairement aux opérateurs que nous avons étudiés jusqu’à présent, ceux-ci doivent être implémentés en tant que fonctions non membres, car l’opérande 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 puisse ê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 dans lequel vous souhaitez afficher les températures dans un format lisible et les lire naturellement depuis 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 une unité (sous forme de char, soit 'C' pour Celsius, soit 'F' pour Fahrenheit). Votre classe doit comporter :
- Des membres privés pour la valeur de température et l’unité
- Un constructeur par défaut qui initialise la température à 0.0 Celsius
- Un constructeur paramétré qui prend une valeur et une unité
- Les accesseurs getValue() et getUnit() (tous deux const)
- Des déclarations friend pour les opérateurs d’insertion (<<) et d’extraction (>>) de flux
Implémentez les opérateurs de flux sous forme de 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é depuis le flux, puis les stocker dans l’objet Temperature.
Les deux opérateurs doivent renvoyer une référence vers le flux afin de permettre l’enchaînement.
main.cpp : lisez deux températures depuis l’entrée. Chaque température est fournie sur une ligne distincte 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. Affichez-les ensuite à l’aide de 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 devrait ê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 température avec exactement une décimale. N’oubliez pas les protections contre les inclusions multiples 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;
}