Vinculações Estruturadas

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 88 de 104.

Bindings estruturados, introduzidos no C++17, permitem descompactar vários valores de arrays, pares, tuplas ou structs em variáveis nomeadas individuais em uma única declaração. Isso torna o código mais limpo e legível ao trabalhar com dados compostos.

A sintaxe usa auto com colchetes contendo os novos nomes de variáveis:

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

int main() {
    // Desempacotando um pair
    std::pair<std::string, int> person{"Alice", 25};
    auto [name, age] = person;
    std::cout << name << " is " << age << "\n";
    
    // Desempacotando um tuple
    std::tuple<int, double, char> data{42, 3.14, 'X'};
    auto [num, pi, letter] = data;
    
    // Desempacotando em laços for baseados em intervalo
    std::map<std::string, int> scores{{"Bob", 90}, {"Carol", 85}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }
}

As vinculações estruturadas também funcionam com arrays e structs personalizados que têm membros 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;
}

Você pode usar auto& ou const auto& para vincular por referência, evitando cópias e permitindo a modificação dos valores originais quando necessário. Esse recurso é especialmente útil ao iterar sobre contêineres da STL ou ao lidar com funções que retornam vários valores.

Desafio

Fácil

Vamos criar um analisador de notas de alunos que demonstra o poder das vinculações estruturadas. Você criará um sistema que processa registros de alunos e dados de cursos, usando vinculações estruturadas para desempacotar pares, tuplas e structs de forma elegante ao longo do código.

Você organizará seu código em três arquivos:

Student.h: Defina uma struct Student com membros públicos para o nome do aluno (std::string), ID (int) e GPA (double). Crie também uma função chamada createStudent que receba um nome, um ID e um GPA, e retorne uma struct Student.
GradeUtils.h: Crie funções utilitárias para o processamento de notas.
Defina uma função getGradeInfo que receba uma pontuação numérica (inteiro) e retorne um std::tuple contendo três valores: a nota em letra (std::string), os pontos da nota (double) e se houve aprovação (bool). Use esta escala de notas:
- 90+ : "A", 4.0, true
- 80-89: "B", 3.0, true
- 70-79: "C", 2.0, true
- 60-69: "D", 1.0, true
- Abaixo de 60: "F", 0.0, false
Defina também uma função makeScorePair que receba o nome de um curso (std::string) e a pontuação (int), retornando um std::pair desses valores.
main.cpp: Leia quatro entradas:
1. Nome do aluno (string)
2. ID do aluno (inteiro)
3. Nome do curso (string)
4. Pontuação (inteiro)
Use vinculações estruturadas ao longo da sua função principal:
1. Chame createStudent com o nome, o ID e um GPA de espaço reservado igual a 0.0. Use vinculações estruturadas para desempacotar a struct retornada em variáveis individuais e, em seguida, imprima: Student: [name] (ID: [id])
2. Chame makeScorePair com o nome do curso e a pontuação. Use vinculações estruturadas para desempacotar o par e, em seguida, imprima: Course: [course], Score: [score]
3. Chame getGradeInfo com a pontuação. Use vinculações estruturadas para desempacotar os três elementos da tupla e, em seguida, imprima:
```
Grade: [letter]
Points: [points]
Passing: [yes/no]
```
  (Imprima "yes" se passing for true e "no" se for false)

Por exemplo, com as entradas Alice, 1001, Math e 85:

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

Com as entradas Bob, 2002, Physics e 55:

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

Lembre-se de incluir <tuple> e <utility> quando necessário. A principal ideia é entender como as vinculações estruturadas permitem desempacotar tipos compostos, pares, tuplas e structs em variáveis nomeadas em uma única declaração legível.

Experimente você mesmo

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

int main() {
    // Ler entradas
    std::string studentName;
    int studentId;
    std::string courseName;
    int score;
    
    std::cin >> studentName;
    std::cin >> studentId;
    std::cin >> courseName;
    std::cin >> score;
    
    // TODO: Chame createStudent com name, id e GPA placeholder de 0.0
    // Use structured bindings para desempacotar a struct: auto [name, id, gpa] = ...
    // Imprima: Student: [name] (ID: [id])
    
    
    // TODO: Chame makeScorePair com o nome do curso e score
    // Use structured bindings para desempacotar o pair: auto [course, sc] = ...
    // Imprima: Course: [course], Score: [score]
    
    
    // TODO: Chame getGradeInfo com o score
    // Use structured bindings para desempacotar a tuple: auto [letter, points, passing] = ...
    // Imprima:
    // Grade: [letter]
    // Points: [points]
    // Passing: [yes/no] (imprima "yes" se passing for true, "no" se false)
    
    
    return 0;
}