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é.
Défi
FacileConstruisons 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 classeStudentqui illustre une encapsulation adéquate avec une classeGradeimbriquée.Ta classe
Gradeimbriquée (déclarée dans la section publique deStudent) 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éthodesgetCourseName()etgetScore()pour accéder aux données. La classeGradegarde ses données privées ; même imbriquée dansStudent, elle conserve sa propre encapsulation.La classe
Studentdoit avoir des membres privés pour le nom de l'étudiant (string), son identifiant (int) et une collection de pointeurs vers desGrade. Fournis :- Un constructeur qui prend le nom et l'identifiant de l'étudiant
- Les accesseurs
getName()etgetStudentId()(tous deux const) - Une méthode
addGrade(const std::string& course, double score)qui crée une nouvelle instance deGradeet 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
Studentavec 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;
}
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
1Fondamentaux de la POO
Fichiers externesGénération et compilation en C++Fichiers d’en-tête et fichiers sourceEspaces de noms et portéeIntroduction à la POO en C++Classes et objetsLe pointeur « this »Méthodes (fonctions membres)Attributs (membres de données)Bases des constructeurs et destructeursRécapitulatif - Calculatrice simple4Propriétés de classe
Membres d’instance et statiquesAccesseurs et mutateursFonctions membres constMot-clé mutableMéthodes et variables statiquesFonctions et classes amiesRécapitulatif - Gestionnaire de compte bancaire7Héritage
Héritage de baseNiveaux d’accès de l’héritageOrdre d’appel des constructeurs et destructeursRedéfinition des méthodesFonctions virtuelles et VTableHéritage multipleHéritage virtuelRécapitulatif : hiérarchie des employés10Vue d’ensemble de la STL
Vue d’ensemble et philosophie de la STLConteneurs de la STLItérateursAlgorithmes de la STLFoncteurs et expressions lambdaRécapitulatif - fréquence des mots13Modèles de conception, partie 1
Introduction aux modèles de conceptionModèle SingletonFabrique et fabrique abstraiteModèle BuilderModèle ObserverModèle Strategy2Gestion de la mémoire
Mémoire de pile ou de tasPointeurs et référencesMémoire dynamique (new/delete)Pointeurs intelligents en C++RAII en C++Récapitulatif - Gestionnaire de tableaux dynamiques5Encapsulation
Spécificateurs d’accès en C++Spécificateurs d’accès en profondeurMasquage de l’informationStruct vs classeClasses imbriquées et internesRécapitulatif - Système de gestion des dossiers étudiants8Polymorphisme
Polymorphisme à la compilation vs à l’exécutionSurcharge de fonctionsRetour sur les fonctions virtuellesFonctions virtuelles puresClasses abstraitesConception d’interfaces en C++Conversion dynamique et RTTIRécapitulatif - Calculateur de formes3Constructeurs et destructeurs
Constructeur par défautConstructeur paramétréConstructeur de copieConstructeur de déplacementListes d’initialisation des constructeursConstructeurs déléguésApprofondissement des destructeursRègle des trois / cinq / zéroRécapitulatif - Classe String6Surcharge des opérateurs
Introduction à la surcharge des opérateursSurcharge des opérateurs arithmétiquesSurcharge des opérateurs de comparaisonOpérateurs de fluxSurcharge de l’opérateur d’affectationSurcharge des opérateurs [] et ()Opérateurs de conversion de typeRécapitulatif – Classe Matrix9Templates
Templates de fonctionsTemplates de classesSpécialisation des templatesTemplates variadiquesBases de SFINAE et des traits de typesRécapitulatif - Conteneur génériqueEntraînez-vous par vous-même : Compilateur C++ en ligne