Wiederholung – Studierendenverwaltungssystem
Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 39 von 104.
Jetzt kannst du dein Wissen über Kapselung in die Praxis umsetzen! In dieser Herausforderung erstellst du ein System zur Verwaltung von Schülerdaten, das den richtigen Einsatz von Zugriffsspezifizierern, Informationsverbergung und verschachtelten Klassen veranschaulicht.
Dein System verwaltet Schülerdaten nach diesen Prinzipien der Kapselung:
- Private Datenelemente, um sensible Informationen wie Noten und Schüler-IDs zu schützen
- Öffentliche Schnittstelle mit Gettern und kontrollierten Settern
- Eine verschachtelte Klasse zur Darstellung einzelner Kursnoten, sodass dieses Implementierungsdetail innerhalb der Schülerklasse gekapselt bleibt
Hier ist die Struktur, die du implementieren wirst:
class Student {
public:
class Grade { // Verschachtelte Klasse für Kursnoten
// ...
};
// Öffentliche Schnittstelle für den Zugriff auf Studentendaten
private:
std::string name;
int studentId;
// Sammlung von Noten
};Diese Herausforderung vereint alles aus diesem Kapitel: die Wahl geeigneter Zugriffsebenen, das Verbergen von Implementierungsdetails hinter einer klaren Schnittstelle und die Verwendung verschachtelter Klassen zur Organisation verwandter Typen. Überlege sorgfältig, was zugänglich sein sollte und was verborgen bleiben sollte.
Aufgabe
EinfachLass uns ein Schülerverwaltungssystem erstellen, das alles zusammenführt, was du über Kapselung gelernt hast. Du erstellst ein System, in dem Schülerdaten angemessen geschützt werden, Noten über eine verschachtelte Klasse verwaltet werden und alle Interaktionen über eine übersichtliche öffentliche Schnittstelle erfolgen.
Du erstellst zwei Dateien, um deinen Code zu strukturieren:
Student.h: Definiere eineStudent-Klasse, die eine ordnungsgemäße Kapselung mit einer verschachteltenGrade-Klasse veranschaulicht.Deine verschachtelte
Grade-Klasse (deklariert im öffentlichen Bereich vonStudent) sollte einen Kursnamen (string) und eine Punktzahl (double) speichern. Gib ihr einen Konstruktor, der beide Werte entgegennimmt, und stelle die MethodengetCourseName()undgetScore()bereit, um auf die Daten zuzugreifen. DieGrade-Klasse hält ihre Daten privat. Obwohl sie inStudentverschachtelt ist, behält sie ihre eigene Kapselung bei.Die
Student-Klasse sollte private Member für den Namen des Schülers (string), die Schüler-ID (int) und eine Sammlung vonGrade-Zeigern haben. Stelle Folgendes bereit:- Einen Konstruktor, der den Namen und die Schüler-ID entgegennimmt
- Die Getter
getName()undgetStudentId()(beide const) - Eine Methode
addGrade(const std::string& course, double score), die ein neuesGradeerstellt und zum Datensatz des Schülers hinzufügt (nur hinzufügen, wenn die Punktzahl inklusive zwischen 0 und 100 liegt) - Eine Methode
getAverageGrade()(const), die den Durchschnitt aller Noten berechnet und zurückgibt, oder 0.0, wenn keine Noten vorhanden sind - Eine Methode
displayRecord()(const), die den vollständigen Datensatz des Schülers anzeigt
Vergiss nicht, die dynamisch zugewiesenen Noten im Destruktor freizugeben und geeignete Header Guards einzufügen.
main.cpp: Lies einen Schülernamen, eine Schüler-ID und drei Kursnoten aus der Eingabe ein. Das Eingabeformat besteht aus fünf Zeilen: Name, ID und anschließend drei Zeilen, die jeweils einen Kursnamen und eine durch ein Leerzeichen getrennte Punktzahl enthalten (z. B.Math 95.5).Erstelle einen
Studentmit dem Namen und der ID, füge alle drei Noten hinzu und zeige dann den vollständigen Datensatz an.Das Ausgabeformat für
displayRecord()sollte wie folgt aussehen:Student: <name> (ID: <id>) Grades: <course1>: <score1> <course2>: <score2> <course3>: <score3> Average: <average>
Formatiere alle Punktzahlen und den Durchschnitt mit einer Dezimalstelle mithilfe von std::fixed und std::setprecision(1) aus <iomanip>. Wandle die ID mit std::stoi() und die Punktzahlen mit std::stod() um.
Diese Herausforderung vereint private Datenelemente, öffentliche Getter, kontrollierte Setter mit Validierung und eine verschachtelte Klasse. Zusammen sorgen sie für ein gut gekapseltes Schülerverwaltungssystem.
Probier es selbst
#include <iostream>
#include <string>
#include <sstream>
#include "Student.h"
int main() {
// Namen des Studierenden einlesen
std::string name;
std::getline(std::cin, name);
// ID des Studierenden einlesen
std::string idStr;
std::getline(std::cin, idStr);
int studentId = std::stoi(idStr);
// Drei Kursnoten einlesen (Format: "CourseName Score")
std::string line1, line2, line3;
std::getline(std::cin, line1);
std::getline(std::cin, line2);
std::getline(std::cin, line3);
// TODO: Jede Zeile parsen, um Kursnamen und Punktzahl zu extrahieren
// std::stod() verwenden, um Punktzahl-Strings in double-Werte umzuwandeln
// TODO: Ein Student-Objekt mit dem Namen und der ID erstellen
// TODO: Alle drei Noten zum Student-Objekt hinzufügen
// TODO: Den vollständigen Datensatz des Studierenden anzeigen
return 0;
}
Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.
Alle Lektionen in Objektorientierte Programmierung
1Grundlagen der OOP
Externe DateienC++ Build & KompilierungHeader-Dateien & QuelldateienNamespaces & GültigkeitsbereichEinführung in OOP mit C++Klassen vs. ObjekteDer „this“-ZeigerMethoden (Member-Funktionen)Attribute (Datenmember)Grundlagen zu Ctors & DtorsRückblick – Einfacher Taschenrechner4Klassenattribute
Instanz- vs. statische MemberGetter und SetterConst-MemberfunktionenMutable-SchlüsselwortStatische Methoden und VariablenFriend-Funktionen und -KlassenZusammenfassung – Bankkontoverwaltung7Vererbung
Grundlagen der VererbungZugriffsebenen bei der VererbungAufrufreihenfolge von Ctor & DtorÜberschreiben von MethodenVirtuelle Funktionen & VTableMehrfachvererbungVirtuelle VererbungRückblick – Mitarbeiterhierarchie2Speicherverwaltung
Stack- vs. Heap-SpeicherZeiger und ReferenzenDynamischer Speicher (new/delete)Intelligente Zeiger in C++RAII in C++Rückblick – Dynamischer Array-Manager5Kapselung
Zugriffsbezeichner in C++Zugriffsbezeichner im DetailInformationsverbergungStruct vs. KlasseVerschachtelte und innere KlassenWiederholung – Studierendenverwaltungssystem8Polymorphie
Polymorphie zur Compilezeit vs. LaufzeitFunktionsüberladungVirtuelle Funktionen erneut betrachtetRein virtuelle FunktionenAbstrakte KlassenInterface-Design in C++Dynamic Casting & RTTIRückblick – Shape-Calculator3Konstruktoren & Destruktoren
StandardkonstruktorParametrisierter KonstruktorKopierkonstruktorMove-KonstruktorKonstruktor-InitialisierungslistenDelegierende KonstruktorenDestruktor im DetailDrei-/Fünf-/Null-RegelZusammenfassung – String-Klasse6Operatorüberladung
Einführung in die OperatorüberladungArithmetische OperatorüberladungVergleichsoperatorüberladungStream-OperatorenZuweisungsoperatorüberladungÜberladung der Operatoren [] und ()TypkonvertierungsoperatorenWiederholung – Matrix-Klasse9Templates
FunktionstemplatesKlassen-TemplatesTemplate-SpezialisierungVariadische TemplatesGrundlagen zu SFINAE und Type TraitsRückblick – Generischer ContainerÜbe selbstständig: Online-C++-Compiler