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 de flux (<<) et d'extraction (>>) 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 ne fait que lire les données, tandis que l'extraction prend une référence non-const car il 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;    // Lit 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 en Celsius (sous forme de double) et une étiquette d'unité (sous forme de char, soit 'C' pour Celsius ou 'F' pour Fahrenheit). Votre classe doit avoir :
- 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 (getters) getValue() et getUnit() (tous deux const)
- Des déclarations d'amitié (friend) pour les opérateurs d'insertion de flux (<<) et d'extraction (>>)
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 renvoyer 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.

Aide-mémoire

Les opérateurs d'insertion de flux (<<) et d'extraction (>>) permettent aux classes personnalisées de fonctionner avec std::cout et std::cin. Ces opérateurs doivent être implémentés en tant que fonctions non-membres car l'opérande de gauche est un objet de flux, et non votre classe.

Syntaxe de base

class Point {
    int x, y;
    
public:
    Point(int x, int y) : x(x), y(y) {}
    
    // Declare as friend to access private members
    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;
}

Points clés

Les deux opérateurs renvoient une référence au flux pour permettre le chaînage (par exemple, std::cout << p1 << p2)
L'opérateur d'insertion (<<) prend l'objet par référence const puisqu'il ne fait que lire les données
L'opérateur d'extraction (>>) prend une référence non-const car il modifie l'objet
Utilisez des déclarations friend pour permettre à ces fonctions non-membres d'accéder aux membres privés

Exemple d'utilisation

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

Point p2(0, 0);
std::cin >> p2;    // Read two integers into p2

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 à partir de std::cin
    
    // TODO: Afficher les températures en utilisant l'opérateur d'insertion (<<)
    // Format :
    // Temperature 1: <temp1>
    // Temperature 2: <temp2>
    
    return 0;
}