Bindings estructurados

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

Las asignaciones estructuradas, introducidas en C++17, te permiten desempaquetar varios valores de matrices, pares, tuplas o estructuras en variables individuales con nombre en una sola declaración. Esto hace que el código sea más limpio y legible al trabajar con datos compuestos.

La sintaxis usa auto con corchetes que contienen los nuevos nombres de variables:

#include <iostream>
#include <map>
#include <tuple>

int main() {
    // Desempaquetando un pair
    std::pair<std::string, int> person{"Alice", 25};
    auto [name, age] = person;
    std::cout << name << " is " << age << "\n";
    
    // Desempaquetando un tuple
    std::tuple<int, double, char> data{42, 3.14, 'X'};
    auto [num, pi, letter] = data;
    
    // Desempaquetando en bucles for basados en rangos
    std::map<std::string, int> scores{{"Bob", 90}, {"Carol", 85}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }
}

Las vinculaciones estructuradas también funcionan con matrices y estructuras personalizadas que tienen miembros públicos:

struct Point {
    double x;
    double y;
};

Point getOrigin() { return {0.0, 0.0}; }

int main() {
    auto [x, y] = getOrigin();
    
    int arr[3] = {1, 2, 3};
    auto [a, b, c] = arr;
}

Puedes usar auto& o const auto& para vincular por referencia, evitando copias y permitiendo modificar los valores originales cuando sea necesario. Esta característica es especialmente útil al iterar sobre contenedores de STL o al manejar funciones que devuelven múltiples valores.

Desafío

Fácil

Construyamos un analizador de calificaciones de estudiantes que muestre el poder de las vinculaciones estructuradas. Crearás un sistema que procese registros de estudiantes y datos de cursos, usando vinculaciones estructuradas para desempaquetar elegantemente pares, tuplas y estructuras a lo largo de tu código.

Organizarás tu código en tres archivos:

Student.h: Define una estructura Student con miembros públicos para el nombre del estudiante (std::string), el ID (int) y el GPA (double). También crea una función llamada createStudent que reciba un nombre, un ID y un GPA, y devuelva una estructura Student.
GradeUtils.h: Crea funciones de utilidad para procesar calificaciones.
Define una función getGradeInfo que reciba una puntuación numérica (entero) y devuelva un std::tuple que contenga tres valores: la calificación con letra (std::string), los puntos de calificación (double) y si se aprobó (bool). Usa esta escala de calificación:
- 90+ : "A", 4.0, true
- 80-89: "B", 3.0, true
- 70-79: "C", 2.0, true
- 60-69: "D", 1.0, true
- Menos de 60: "F", 0.0, false
También define una función makeScorePair que reciba el nombre de un curso (std::string) y la puntuación (int), y devuelva un std::pair de esos valores.
main.cpp: Lee cuatro entradas:
1. Nombre del estudiante (cadena)
2. ID del estudiante (entero)
3. Nombre del curso (cadena)
4. Puntuación (entero)
Usa vinculaciones estructuradas a lo largo de tu función principal:
1. Llama a createStudent con el nombre, el ID y un GPA de marcador de posición de 0.0. Usa vinculaciones estructuradas para desempaquetar la estructura devuelta en variables individuales y, después, imprime: Student: [name] (ID: [id])
2. Llama a makeScorePair con el nombre del curso y la puntuación. Usa vinculaciones estructuradas para desempaquetar el par y, después, imprime: Course: [course], Score: [score]
3. Llama a getGradeInfo con la puntuación. Usa vinculaciones estructuradas para desempaquetar los tres elementos de la tupla y, después, imprime:
```
Grade: [letter]
Points: [points]
Passing: [yes/no]
```
  (Imprime "yes" si passing es true y "no" si es false)

Por ejemplo, con las entradas Alice, 1001, Math y 85:

Student: Alice (ID: 1001)
Course: Math, Score: 85
Grade: B
Points: 3
Passing: yes

Con las entradas Bob, 2002, Physics y 55:

Student: Bob (ID: 2002)
Course: Physics, Score: 55
Grade: F
Points: 0
Passing: no

Recuerda incluir <tuple> y <utility> donde sea necesario. La idea clave es cómo las vinculaciones estructuradas te permiten desempaquetar tipos compuestos, pares, tuplas y estructuras en variables con nombre mediante una sola declaración legible.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Student.h"
#include "GradeUtils.h"

int main() {
    // Leer entradas
    std::string studentName;
    int studentId;
    std::string courseName;
    int score;
    
    std::cin >> studentName;
    std::cin >> studentId;
    std::cin >> courseName;
    std::cin >> score;
    
    // TODO: Llama a createStudent con name, id y GPA de marcador de posición de 0.0
    // Usa structured bindings para desempaquetar la struct: auto [name, id, gpa] = ...
    // Imprime: Student: [name] (ID: [id])
    
    
    // TODO: Llama a makeScorePair con el nombre del curso y score
    // Usa structured bindings para desempaquetar el pair: auto [course, sc] = ...
    // Imprime: Course: [course], Score: [score]
    
    
    // TODO: Llama a getGradeInfo con el score
    // Usa structured bindings para desempaquetar la tuple: auto [letter, points, passing] = ...
    // Imprime:
    // Grade: [letter]
    // Points: [points]
    // Passing: [yes/no] (imprime "yes" si passing es true, "no" si es false)
    
    
    return 0;
}