Strukturierte Bindungen

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 88 von 104.

Strukturierte Bindungen, die in C++17 eingeführt wurden, ermöglichen es dir, mehrere Werte aus Arrays, Paaren, Tupeln oder Strukturen in einer einzigen Deklaration in einzelne benannte Variablen zu entpacken. Dadurch wird der Code bei der Arbeit mit zusammengesetzten Daten übersichtlicher und besser lesbar.

Die Syntax verwendet auto mit eckigen Klammern, die die neuen Variablennamen enthalten:

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

int main() {
    // Entpacken eines Paars
    std::pair<std::string, int> person{"Alice", 25};
    auto [name, age] = person;
    std::cout << name << " is " << age << "\n";
    
    // Entpacken eines Tuples
    std::tuple<int, double, char> data{42, 3.14, 'X'};
    auto [num, pi, letter] = data;
    
    // Entpacken in bereichsbasierten for-Schleifen
    std::map<std::string, int> scores{{"Bob", 90}, {"Carol", 85}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }
}

Strukturierte Bindings funktionieren auch mit Arrays und benutzerdefinierten Structs, die öffentliche Member haben:

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

Du kannst auto& oder const auto& verwenden, um per Referenz zu binden, Kopien zu vermeiden und bei Bedarf die ursprünglichen Werte zu ändern. Diese Funktion ist besonders nützlich, wenn du über STL-Container iterierst oder Funktionen behandelst, die mehrere Werte zurückgeben.

Aufgabe

Einfach

Erstellen wir einen Studentennoten-Analyzer, der die Leistungsfähigkeit strukturierter Bindungen demonstriert. Du erstellst ein System, das Studentendatensätze und Kursdaten verarbeitet und strukturierte Bindungen verwendet, um Paare, Tupel und Strukturen in deinem gesamten Code elegant zu entpacken.

Du organisierst deinen Code über drei Dateien:

Student.h: Definiere eine Student-Struktur mit öffentlichen Membern für den Namen des Studenten (std::string), die ID (int) und den GPA (double). Erstelle außerdem eine Funktion namens createStudent, die einen Namen, eine ID und einen GPA entgegennimmt und eine Student-Struktur zurückgibt.
GradeUtils.h: Erstelle Hilfsfunktionen für die Notenverarbeitung.
Definiere eine Funktion getGradeInfo, die eine numerische Punktzahl (Ganzzahl) entgegennimmt und ein std::tuple mit drei Werten zurückgibt: die Buchstabennote (std::string), die Notenpunkte (double) und die Information, ob die Leistung bestanden ist (bool). Verwende diese Bewertungsskala:
- 90+ : "A", 4.0, true
- 80-89: "B", 3.0, true
- 70-79: "C", 2.0, true
- 60-69: "D", 1.0, true
- Unter 60: "F", 0.0, false
Definiere außerdem eine Funktion makeScorePair, die einen Kursnamen (std::string) und eine Punktzahl (int) entgegennimmt und ein std::pair mit diesen Werten zurückgibt.
main.cpp: Lies vier Eingaben ein:
1. Name des Studenten (String)
2. Studenten-ID (Ganzzahl)
3. Kursname (String)
4. Punktzahl (Ganzzahl)
Verwende strukturierte Bindungen in deiner gesamten Main-Funktion:
1. Rufe createStudent mit dem Namen, der ID und einem Platzhalter-GPA von 0.0 auf. Verwende strukturierte Bindungen, um die zurückgegebene Struktur in einzelne Variablen zu entpacken, und gib anschließend Folgendes aus: Student: [name] (ID: [id])
2. Rufe makeScorePair mit dem Kursnamen und der Punktzahl auf. Verwende strukturierte Bindungen, um das Paar zu entpacken, und gib anschließend Folgendes aus: Course: [course], Score: [score]
3. Rufe getGradeInfo mit der Punktzahl auf. Verwende strukturierte Bindungen, um alle drei Tupelelemente zu entpacken, und gib anschließend Folgendes aus:
```
Grade: [letter]
Points: [points]
Passing: [yes/no]
```
  (Gib "yes" aus, wenn passing true ist, und "no", wenn es false ist.)

Beispielsweise mit den Eingaben Alice, 1001, Math und 85:

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

Mit den Eingaben Bob, 2002, Physics und 55:

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

Denke daran, bei Bedarf <tuple> und <utility> einzubinden. Die zentrale Erkenntnis ist, wie strukturierte Bindungen es dir ermöglichen, zusammengesetzte Typen, Paare, Tupel und Strukturen in einer einzigen, gut lesbaren Deklaration in benannte Variablen zu entpacken.

Probier es selbst

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

int main() {
    // Eingaben lesen
    std::string studentName;
    int studentId;
    std::string courseName;
    int score;
    
    std::cin >> studentName;
    std::cin >> studentId;
    std::cin >> courseName;
    std::cin >> score;
    
    // TODO: Rufe createStudent mit name, id und Platzhalter-GPA von 0.0 auf
    // Verwende strukturierte Bindungen, um die Struct zu entpacken: auto [name, id, gpa] = ...
    // Ausgeben: Student: [name] (ID: [id])
    
    
    // TODO: Rufe makeScorePair mit Kursname und score auf
    // Verwende strukturierte Bindungen, um das Paar zu entpacken: auto [course, sc] = ...
    // Ausgeben: Course: [course], Score: [score]
    
    
    // TODO: Rufe getGradeInfo mit dem score auf
    // Verwende strukturierte Bindungen, um das Tupel zu entpacken: auto [letter, points, passing] = ...
    // Ausgeben:
    // Grade: [letter]
    // Points: [points]
    // Passing: [yes/no] (drucke "yes", wenn passing true ist, "no", wenn false)
    
    
    return 0;
}