Récapitulatif - Système de gestion des dossiers étudiants

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

Il est temps de mettre en pratique tes connaissances sur l'encapsulation ! Dans ce défi, tu vas créer un système de gestion des dossiers des étudiants qui démontre l'utilisation correcte des spécificateurs d'accès, de la dissimulation des informations et des classes imbriquées.

Ton système gérera les données des étudiants en appliquant les principes d'encapsulation suivants :

Membres de données privés pour protéger les informations sensibles telles que les notes et les identifiants des étudiants
Interface publique avec des accesseurs et des mutateurs contrôlés
Une classe imbriquée pour représenter les notes des différents cours, en gardant ce détail d'implémentation contenu dans la classe étudiant

Voici la structure que tu vas implémenter :

class Student {
public:
    class Grade {    // Classe imbriquée pour les notes de cours
        // ...
    };
    
    // Interface publique pour interagir avec les données de l'étudiant
    
private:
    std::string name;
    int studentId;
    // Collection de notes
};

Ce défi combine tous les éléments de ce chapitre : choisir les niveaux d'accès appropriés, dissimuler les détails d'implémentation derrière une interface claire et utiliser des classes imbriquées pour organiser les types associés. Réfléchis attentivement à ce qui doit être accessible et à ce qui doit rester caché.

Défi

Facile

Construisons un système de gestion des dossiers étudiants qui rassemble tout ce que vous avez appris sur l'encapsulation. Vous allez créer un système dans lequel les données des étudiants sont correctement protégées, les notes sont gérées au moyen d'une classe imbriquée et toutes les interactions se font via une interface publique claire.

Vous allez créer deux fichiers pour organiser votre code :

Student.h : définissez une classe Student qui illustre une encapsulation correcte avec une classe Grade imbriquée.
Votre classe Grade imbriquée (déclarée dans la section publique de Student) doit stocker le nom d'un cours (chaîne de caractères) et une note (double). Donnez-lui un constructeur qui prend ces deux valeurs et fournissez-lui les méthodes getCourseName() et getScore() pour accéder aux données. La classe Grade conserve ses données privées ; même si elle est imbriquée dans Student, elle maintient sa propre encapsulation.

La classe Student doit posséder des membres privés pour le nom de l'étudiant (chaîne de caractères), son identifiant étudiant (int) et une collection de pointeurs vers des objets Grade. Fournissez :
- Un constructeur qui prend le nom et l'identifiant étudiant
- Les accesseurs getName() et getStudentId() (tous deux const)
- Une méthode addGrade(const std::string& course, double score) qui crée une nouvelle Grade et l'ajoute au dossier de l'étudiant (ajoutez-la uniquement si la note est comprise entre 0 et 100 inclus)
- Une méthode getAverageGrade() (const) qui calcule et renvoie la moyenne de toutes les notes, ou 0.0 si aucune note n'existe
- Une méthode displayRecord() (const) qui affiche le dossier complet de l'étudiant
N'oubliez pas de libérer les notes allouées dynamiquement dans le destructeur et d'inclure des protections d'en-tête appropriées.
main.cpp : lisez un nom d'étudiant, un identifiant étudiant et les notes de trois cours à partir de l'entrée. Le format de l'entrée sera composé de cinq lignes : le nom, l'identifiant, puis trois lignes contenant chacune un nom de cours et une note séparés par un espace (par exemple, Math 95.5).
Créez un objet Student avec le nom et l'identifiant, ajoutez les trois notes, puis affichez le dossier complet.

Le format de sortie de displayRecord() doit être :
```
Student: <name> (ID: <id>)
Grades:
  <course1>: <score1>
  <course2>: <score2>
  <course3>: <score3>
Average: <average>
```

Formatez toutes les notes et la moyenne avec une décimale en utilisant std::fixed et std::setprecision(1) de <iomanip>. Convertissez l'identifiant avec std::stoi() et les notes avec std::stod().

Ce défi combine des membres de données privés, des accesseurs publics, des méthodes de modification contrôlées avec validation et une classe imbriquée : tous ces éléments fonctionnent ensemble pour créer un système de gestion des dossiers étudiants correctement encapsulé.

Essayez vous-même

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

int main() {
    // Lire le nom de l'étudiant
    std::string name;
    std::getline(std::cin, name);
    
    // Lire l'ID de l'étudiant
    std::string idStr;
    std::getline(std::cin, idStr);
    int studentId = std::stoi(idStr);
    
    // Lire trois notes de cours (format : "CourseName Score")
    std::string line1, line2, line3;
    std::getline(std::cin, line1);
    std::getline(std::cin, line2);
    std::getline(std::cin, line3);
    
    // TODO: Analyser chaque ligne pour extraire le nom du cours et la note
    // Utiliser std::stod() pour convertir les chaînes de notes en doubles
    
    // TODO: Créer un objet Student avec le nom et l'ID
    
    // TODO: Ajouter les trois notes à l'étudiant
    
    // TODO: Afficher le dossier complet de l'étudiant
    
    return 0;
}