Operadores de flujo (Stream)

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 43 de 104.

Los operadores de inserción (<<) y extracción (>>) de flujo le permiten usar sus clases personalizadas con std::cout y std::cin. A diferencia de los operadores que hemos cubierto hasta ahora, estos deben implementarse como funciones no miembro porque el operando izquierdo es un flujo, no su clase.

class Point {
    int x, y;
    
public:
    Point(int x, int y) : x(x), y(y) {}
    
    // Declarar como friend para acceder a los miembros privados
    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;
}

Ambos operadores devuelven una referencia al flujo, permitiendo el encadenamiento como std::cout << p1 << p2. El operador de inserción toma el objeto por referencia const, ya que solo lee datos, mientras que la extracción toma una referencia no const porque modifica el objeto.

Ahora puedes usar Point naturalmente con streams:

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

Point p2(0, 0);
std::cin >> p2;    // Lee dos enteros en p2

Desafío

Fácil

Construyamos una clase Temperature que se pueda usar sin problemas con std::cout y std::cin mediante la sobrecarga de los operadores de flujo. Este es un escenario práctico en el que quieres mostrar temperaturas en un formato legible y leerlas de la entrada de forma natural.

Crearás dos archivos para organizar tu código:

Temperature.h: Define una clase Temperature que almacene un valor de temperatura (como un double) y una etiqueta de unidad (como un char, ya sea 'C' para Celsius o 'F' para Fahrenheit). Tu clase debe tener:
- Miembros privados para el valor de temperatura y la unidad
- Un constructor predeterminado que inicialice el valor a 0.0 Celsius
- Un constructor parametrizado que reciba un valor y una unidad
- Los getters getValue() y getUnit() (ambos const)
- Declaraciones friend para los operadores de inserción (<<) y extracción (>>) de flujo
Implementa los operadores de flujo como funciones no miembro:
- El operador de inserción debe mostrar la temperatura en el formato VALUE UNIT (por ejemplo, 25.5 C o 77.9 F). Usa un decimal para el valor.
- El operador de extracción debe leer un valor y un carácter de unidad del flujo y almacenarlos en el objeto Temperature.
Ambos operadores deben devolver una referencia al flujo para permitir el encadenamiento.
main.cpp: Lee dos temperaturas de la entrada. Cada temperatura se proporciona en una línea separada con el formato value unit (por ejemplo, 25.5 C).
Crea dos objetos Temperature usando el operador de extracción para leerlos desde std::cin. Después, muéstralos usando el operador de inserción con este formato:
```
Temperature 1: <temp1>
Temperature 2: <temp2>
```
Por ejemplo, si la entrada es:
```
25.5 C
98.6 F
```
La salida debería ser:
```
Temperature 1: 25.5 C
Temperature 2: 98.6 F
```

Usa std::fixed y std::setprecision(1) de <iomanip> para dar formato al valor de temperatura con exactamente un decimal. No olvides las protecciones contra inclusiones múltiples en tu archivo de cabecera.

Pruébalo tú mismo

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

int main() {
    // TODO: Crear dos objetos Temperature
    
    // TODO: Usar el operador de extracción (>>) para leer dos temperaturas de std::cin
    
    // TODO: Mostrar las temperaturas usando el operador de inserción (<<)
    // Formato:
    // Temperature 1: <temp1>
    // Temperature 2: <temp2>
    
    return 0;
}