Plateforme d'E-Learning

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

Défi

Facile

Construisons une plateforme d'apprentissage en ligne qui rassemble tous les concepts de la POO que vous avez maîtrisés tout au long de ce cours. Vous allez créer un système qui gère des cours, différents types de leçons et suit les progrès des étudiants — illustrant les hiérarchies d'héritage, le polymorphisme, les pointeurs intelligents et les patrons de conception travaillant en harmonie.

Vous organiserez votre code sur six fichiers :

User.h : Créez une hiérarchie d'utilisateurs avec une classe de base User et deux classes dérivées : Student et Instructor.
Votre classe de base User doit avoir un nom et un identifiant (ID), avec une méthode virtuelle getRole() qui retourne le type d'utilisateur sous forme de chaîne de caractères, et une méthode getInfo() qui retourne "[name] ([id]) - [role]".

La classe Student suit les identifiants des cours inscrits (utilisez un vecteur de chaînes de caractères) et le nombre de leçons terminées. Ajoutez les méthodes enrollInCourse(const std::string& courseId), completedLesson() pour incrémenter le compteur, et getCompletedCount().

La classe Instructor stocke une chaîne de caractères pour la spécialité et suit les identifiants des cours qu'il enseigne. Ajoutez addCourse(const std::string& courseId) et getSpecialty().
Lesson.h : Construisez une hiérarchie de leçons en utilisant une classe de base abstraite.
Votre classe de base Lesson doit avoir un titre et une durée (en minutes), avec une méthode virtuelle pure complete() qui retourne un message de complétion, et une méthode getType() retournant le type de leçon.

Créez trois classes dérivées :
- VideoLesson : Possède une URL de vidéo. Sa méthode complete() retourne "Watched video: [title]"
- QuizLesson : Possède un nombre de questions. Sa méthode complete() retourne "Completed quiz: [title] ([questions] questions)"
- TextLesson : Possède un nombre de mots. Sa méthode complete() retourne "Read article: [title]"
Chacune doit surcharger getType() pour retourner respectivement "Video", "Quiz", ou "Text".
Course.h : Créez une classe Course qui possède ses leçons en utilisant des pointeurs intelligents.
Un cours a un titre, un identifiant (ID) et un identifiant d'instructeur. Stockez les leçons sous forme de std::vector<std::unique_ptr<Lesson>> puisque le cours possède ses leçons de manière exclusive.

Ajoutez les méthodes :
- addLesson(std::unique_ptr<Lesson> lesson) — transfère la propriété de la leçon au cours
- getLessonCount() — retourne le nombre de leçons
- getLesson(size_t index) — retourne un pointeur vers la leçon à cet index (ou nullptr si invalide)
- displayCurriculum() — affiche le type et le titre de chaque leçon au format "[index]. [Type]: [title]"
LessonFactory.h : Implémentez le patron de conception Factory pour créer différents types de leçons.
Créez une classe LessonFactory avec une méthode statique createLesson(const std::string& type, const std::string& title, int duration, const std::string& extra) qui retourne un std::unique_ptr<Lesson>.

Le paramètre type détermine quelle leçon créer ("video", "quiz", ou "text"). Le paramètre extra contient des données spécifiques au type : l'URL pour la vidéo, le nombre de questions pour le quiz (à convertir en int), ou le nombre de mots pour le texte (à convertir en int).
Platform.h : Construisez la classe centrale Platform qui coordonne le tout.
Stockez les cours sous forme de std::vector<std::shared_ptr<Course>> et les utilisateurs sous forme de std::vector<std::shared_ptr<User>>.

Implémentez :
- addCourse(std::shared_ptr<Course> course)
- addUser(std::shared_ptr<User> user)
- findCourse(const std::string& id) — retourne un shared_ptr ou nullptr
- findUser(const std::string& id) — retourne un shared_ptr ou nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId) — trouve les deux, inscrit l'étudiant, affiche "Enrolled [name] in [course title]" ou "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex) — trouve l'étudiant et le cours, appelle la méthode complete() de la leçon, incrémente le compteur de leçons terminées de l'étudiant, affiche le message de complétion ou "Could not complete lesson"
main.cpp : Rassemblez tout pour faire la démonstration de votre plateforme.
Lisez quatre entrées :
1. Nom de la plateforme
2. Détails du cours (format : title,courseId,instructorId)
3. Détails de l'étudiant (format : name,studentId)
4. Leçon à ajouter (format : type,title,duration,extra)
Créez la plateforme et affichez "Welcome to [platform name]!". Créez le cours et l'étudiant, ajoutez-les à la plateforme. Utilisez la LessonFactory pour créer la leçon et l'ajouter au cours. Affichez le programme du cours (curriculum). Inscrivez l'étudiant au cours. Terminez la première leçon (index 0) pour cet étudiant. Enfin, affichez les informations de l'étudiant et son nombre de leçons terminées sous la forme "Completed lessons: [count]".

Par exemple, avec les entrées CodeAcademy, C++ Mastery,CPP101,I001, Alice,S001, et video,Introduction to OOP,30,https://example.com/oop :

Welcome to CodeAcademy!
1. Video: Introduction to OOP
Enrolled Alice in C++ Mastery
Watched video: Introduction to OOP
Alice (S001) - Student
Completed lessons: 1

Avec les entrées LearnHub, Python Basics,PY100,I002, Bob,S002, et quiz,Variables Quiz,15,10 :

Welcome to LearnHub!
1. Quiz: Variables Quiz
Enrolled Bob in Python Basics
Completed quiz: Variables Quiz (10 questions)
Bob (S002) - Student
Completed lessons: 1

Ce défi démontre comment les véritables plateformes d'apprentissage en ligne sont structurées — avec une séparation claire entre les utilisateurs, le contenu et la plateforme qui les coordonne. Le patron Factory rend la création de leçons flexible, les pointeurs intelligents assurent une gestion sûre de la mémoire, et le polymorphisme vous permet de traiter tous les types de leçons de manière uniforme alors que chacun se comporte de façon unique.

Essayez vous-même

#include <iostream>
#include <string>
#include <sstream>
#include <memory>
#include "User.h"
#include "Lesson.h"
#include "Course.h"
#include "LessonFactory.h"
#include "Platform.h"

int main() {
    // Lire les entrées
    std::string platformName;
    std::getline(std::cin, platformName);
    
    std::string courseDetails; // format : title,courseId,instructorId
    std::getline(std::cin, courseDetails);
    
    std::string studentDetails; // format : name,studentId
    std::getline(std::cin, studentDetails);
    
    std::string lessonDetails; // format : type,title,duration,extra
    std::getline(std::cin, lessonDetails);
    
    // TODO: Analyser courseDetails pour extraire title, courseId, instructorId
    
    // TODO: Analyser studentDetails pour extraire name, studentId
    
    // TODO: Analyser lessonDetails pour extraire type, title, duration, extra
    
    // TODO: Créer la plateforme et afficher "Welcome to [platform name]!"
    
    // TODO: Créer le cours et l'étudiant, les ajouter à la plateforme
    
    // TODO: Utiliser LessonFactory pour créer la leçon et l'ajouter au cours
    
    // TODO: Afficher le programme du cours
    
    // TODO: Inscrire l'étudiant au cours
    
    // TODO: Terminer la première leçon (index 0) pour l'étudiant
    
    // TODO: Afficher les informations de l'étudiant et le nombre de leçons terminées
    // Format : "Completed lessons: [count]"
    
    return 0;
}