Menu
CoddyTech

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 en encapsulation ! Dans ce défi, tu vas créer un système de dossiers étudiants qui montre comment utiliser correctement les spécificateurs d’accès, le masquage des informations et les classes imbriquées.

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

  • Membres de données privés pour protéger les informations sensibles comme 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 individuelles des cours, en gardant ce détail d’implémentation dans la classe étudiant

Voici la structure que tu vas implémenter :

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

Ce défi rassemble tout ce que tu as appris dans ce chapitre : choisir les niveaux d’accès appropriés, masquer 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 bien à ce qui doit être accessible et à ce qui doit rester masqué.

challenge icon

Défi

Facile

Construisons un système de gestion des dossiers étudiants qui rassemble tout ce que tu as appris sur l'encapsulation. Tu vas 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 par l'intermédiaire d'une interface publique claire.

Tu vas créer deux fichiers pour organiser ton code :

  • Student.h : définis une classe Student qui illustre une encapsulation adéquate avec une classe Grade imbriquée.

    Ta classe Grade imbriquée (déclarée dans la section publique de Student) doit stocker le nom d'un cours (string) et une note (double). Ajoute-lui un constructeur qui prend ces deux valeurs, ainsi que les méthodes getCourseName() et getScore() pour accéder aux données. La classe Grade garde ses données privées ; même imbriquée dans Student, elle conserve sa propre encapsulation.

    La classe Student doit avoir des membres privés pour le nom de l'étudiant (string), son identifiant (int) et une collection de pointeurs vers des Grade. Fournis :

    • Un constructeur qui prend le nom et l'identifiant de l'étudiant
    • Les accesseurs getName() et getStudentId() (tous deux const)
    • Une méthode addGrade(const std::string& course, double score) qui crée une nouvelle instance de Grade et l'ajoute au dossier de l'étudiant (ajoute la note uniquement si elle 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'oublie pas de libérer les notes allouées dynamiquement dans le destructeur et d'inclure des gardes d'inclusion appropriées.

  • main.cpp : lis un nom d'étudiant, son identifiant et trois notes de cours depuis l'entrée. Le format d'entrée comporte 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ée un objet Student avec le nom et l'identifiant, ajoute les trois notes, puis affiche le dossier complet.

    Le format de sortie de displayRecord() doit être :

    Student: <name> (ID: <id>)
    Grades:
      <course1>: <score1>
      <course2>: <score2>
      <course3>: <score3>
    Average: <average>

Formate toutes les notes et la moyenne avec une décimale à l'aide de std::fixed et de std::setprecision(1) de <iomanip>. Convertis 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 : tout cela fonctionne ensemble pour créer un système de gestion des dossiers étudiants bien 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 les notes des trois 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 valeurs de type double
    
    // 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;
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Programmation Orientée Objet

Entraînez-vous par vous-même : Compilateur C++ en ligne