Plateforme d’apprentissage en ligne

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 les cours, différents types de leçons et suit la progression des étudiants, en démontrant des hiérarchies d’héritage, le polymorphisme, les pointeurs intelligents et des patrons de conception fonctionnant 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, avec une méthode virtuelle getRole() qui renvoie le type d’utilisateur sous forme de chaîne, ainsi qu’une méthode getInfo() qui renvoie "[name] ([id]) - [role]".

La classe Student suit les identifiants des cours auxquels l’étudiant est inscrit (utilisez un vecteur de chaînes) ainsi que 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 représentant sa 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 à l’aide d’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 renvoie un message de fin, ainsi qu’une méthode getType() qui renvoie le type de leçon.

Créez trois classes dérivées :
- VideoLesson : possède une URL vidéo. Sa méthode complete() renvoie "Watched video: [title]"
- QuizLesson : possède un nombre de questions. Sa méthode complete() renvoie "Completed quiz: [title] ([questions] questions)"
- TextLesson : possède un nombre de mots. Sa méthode complete() renvoie "Read article: [title]"
Chacune doit redéfinir getType() pour renvoyer respectivement "Video", "Quiz" ou "Text".
Course.h : créez une classe Course qui possède ses leçons à l’aide de pointeurs intelligents.
Un cours possède un titre, un identifiant et l’identifiant de l’instructeur. Stockez les leçons sous forme de std::vector<std::unique_ptr<Lesson>>, puisque le cours est l’unique propriétaire de ses leçons.

Ajoutez les méthodes suivantes :
- addLesson(std::unique_ptr<Lesson> lesson) : transfère la propriété de la leçon au cours
- getLessonCount() : renvoie le nombre de leçons
- getLesson(size_t index) : renvoie un pointeur vers la leçon à cet index (ou nullptr si l’index est invalide)
- displayCurriculum() : affiche le type et le titre de chaque leçon au format "[index]. [Type]: [title]"
LessonFactory.h : implémentez le patron 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 renvoie un std::unique_ptr<Lesson>.

Le paramètre type détermine la leçon à créer ("video", "quiz" ou "text"). Le paramètre extra contient les données spécifiques au type : l’URL pour une vidéo, le nombre de questions pour un quiz (à analyser comme un entier) ou le nombre de mots pour un texte (à analyser comme un entier).
Platform.h : construisez la classe centrale Platform qui coordonne tous les éléments.
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) : renvoie un shared_ptr ou nullptr
- findUser(const std::string& id) : renvoie un shared_ptr ou nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId) : trouve les deux éléments, inscrit l’étudiant, puis 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 nombre de leçons terminées par l’étudiant, puis affiche le message de fin ou "Could not complete lesson"
main.cpp : rassemblez tous les éléments pour présenter 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, puis ajoutez-les à la plateforme. Utilisez LessonFactory pour créer la leçon et l’ajouter au cours. Affichez le programme du cours. Inscrivez l’étudiant au cours. Terminez la première leçon (index 0) pour cet étudiant. Enfin, affichez les informations de l’étudiant ainsi que 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 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 des leçons flexible, les pointeurs intelligents assurent une gestion sûre de la mémoire et le polymorphisme permet de traiter tous les types de leçons de manière uniforme, tout en leur permettant de se comporter chacun 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: Compléter la première leçon (index 0) pour l'étudiant
    
    // TODO: Print the student's info and completed lesson count
    // Format: "Completed lessons: [count]"
    
    return 0;
}