Menu
CoddyTech

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.

challenge icon

Aufgabe

Einfach

Lass 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 eine Student-Klasse, die eine ordnungsgemäße Kapselung mit einer verschachtelten Grade-Klasse veranschaulicht.

    Deine verschachtelte Grade-Klasse (deklariert im öffentlichen Bereich von Student) sollte einen Kursnamen (string) und eine Punktzahl (double) speichern. Gib ihr einen Konstruktor, der beide Werte entgegennimmt, und stelle die Methoden getCourseName() und getScore() bereit, um auf die Daten zuzugreifen. Die Grade-Klasse hält ihre Daten privat. Obwohl sie in Student verschachtelt 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 von Grade-Zeigern haben. Stelle Folgendes bereit:

    • Einen Konstruktor, der den Namen und die Schüler-ID entgegennimmt
    • Die Getter getName() und getStudentId() (beide const)
    • Eine Methode addGrade(const std::string& course, double score), die ein neues Grade erstellt 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 Student mit 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;
}
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

Übe selbstständig: Online-C++-Compiler