Liaisons structurées

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 88 sur 104.

Les liaisons structurées, introduites en C++17, vous permettent de décomposer plusieurs valeurs provenant de tableaux, de paires, de tuples ou de structures en variables nommées individuelles dans une seule déclaration. Cela rend le code plus clair et plus lisible lorsque vous travaillez avec des données composites.

La syntaxe utilise auto avec des crochets contenant les nouveaux noms de variables :

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

int main() {
    // Déballage d'une paire
    std::pair<std::string, int> person{"Alice", 25};
    auto [name, age] = person;
    std::cout << name << " is " << age << "\n";
    
    // Déballage d'un tuple
    std::tuple<int, double, char> data{42, 3.14, 'X'};
    auto [num, pi, letter] = data;
    
    // Déballage dans les boucles for basées sur une plage
    std::map<std::string, int> scores{{"Bob", 90}, {"Carol", 85}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }
}

Les liaisons structurées fonctionnent également avec les tableaux et les structures personnalisées qui possèdent des membres publics :

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;
}

Vous pouvez utiliser auto& ou const auto& pour lier par référence, éviter les copies et permettre la modification des valeurs d’origine lorsque cela est nécessaire. Cette fonctionnalité est particulièrement utile lors de l’itération sur des conteneurs STL ou de la gestion de fonctions qui renvoient plusieurs valeurs.

Défi

Facile

Construisons un analyseur de notes d'étudiants qui met en évidence la puissance des liaisons structurées. Vous allez créer un système qui traite les dossiers des étudiants et les données des cours, en utilisant des liaisons structurées pour décomposer élégamment les paires, les tuples et les structures tout au long de votre code.

Vous organiserez votre code sur trois fichiers :

Student.h : Définissez une structure Student avec des membres publics pour le nom de l'étudiant (std::string), son identifiant (int) et sa moyenne GPA (double). Créez également une fonction appelée createStudent qui prend un nom, un identifiant et une moyenne GPA, puis renvoie une structure Student.
GradeUtils.h : Créez des fonctions utilitaires pour le traitement des notes.
Définissez une fonction getGradeInfo qui prend une note numérique (entier) et renvoie un std::tuple contenant trois valeurs : la note sous forme de lettre (std::string), les points de la note (double) et l'indication de réussite (bool). Utilisez cette échelle de notation :
- 90+ : "A", 4.0, true
- 80-89 : "B", 3.0, true
- 70-79 : "C", 2.0, true
- 60-69 : "D", 1.0, true
- Moins de 60 : "F", 0.0, false
Définissez également une fonction makeScorePair qui prend un nom de cours (std::string) et une note (int), et renvoie une std::pair contenant ces valeurs.
main.cpp : Lisez quatre entrées :
1. Nom de l'étudiant (chaîne)
2. Identifiant de l'étudiant (entier)
3. Nom du cours (chaîne)
4. Note (entier)
Utilisez des liaisons structurées dans toute votre fonction principale :
1. Appelez createStudent avec le nom, l'identifiant et une moyenne GPA temporaire de 0.0. Utilisez des liaisons structurées pour décomposer la structure renvoyée en variables individuelles, puis affichez : Student: [name] (ID: [id])
2. Appelez makeScorePair avec le nom du cours et la note. Utilisez des liaisons structurées pour décomposer la paire, puis affichez : Course: [course], Score: [score]
3. Appelez getGradeInfo avec la note. Utilisez des liaisons structurées pour décomposer les trois éléments du tuple, puis affichez :
```
Grade: [letter]
Points: [points]
Passing: [yes/no]
```
  (Affichez "yes" si la réussite vaut true, et "no" si elle vaut false.)

Par exemple, avec les entrées Alice, 1001, Math et 85 :

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

Avec les entrées Bob, 2002, Physics et 55 :

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

N'oubliez pas d'inclure <tuple> et <utility> lorsque cela est nécessaire. L'idée essentielle est de comprendre comment les liaisons structurées vous permettent de décomposer des types composites, des paires, des tuples et des structures en variables nommées dans une seule déclaration lisible.

Essayez vous-même

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

int main() {
    // Lire les entrées
    std::string studentName;
    int studentId;
    std::string courseName;
    int score;
    
    std::cin >> studentName;
    std::cin >> studentId;
    std::cin >> courseName;
    std::cin >> score;
    
    // TODO: Appeler createStudent avec name, id, et un GPA placeholder de 0.0
    // Utiliser les liaisons structurées pour dépaqueter la struct : auto [name, id, gpa] = ...
    // Afficher : Student: [name] (ID: [id])
    
    
    // TODO: Appeler makeScorePair avec le nom du cours et score
    // Utiliser les liaisons structurées pour dépaqueter la pair : auto [course, sc] = ...
    // Afficher : Course: [course], Score: [score]
    
    
    // TODO: Appeler getGradeInfo avec le score
    // Utiliser les liaisons structurées pour dépaqueter le tuple : auto [letter, points, passing] = ...
    // Afficher :
    // Grade: [letter]
    // Points: [points]
    // Passing: [yes/no] (afficher "yes" si passing est true, "no" si false)
    
    
    return 0;
}