Piattaforma di e-learning

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 103 di 104.

Sfida

Facile

Costruiamo una piattaforma di e-learning che riunisca tutti i concetti di OOP che hai imparato durante questo corso. Creerai un sistema che gestisce i corsi e diversi tipi di lezioni e tiene traccia dei progressi degli studenti, dimostrando come gerarchie di ereditarietà, polimorfismo, puntatori intelligenti e design pattern possano funzionare in armonia.

Organizzerai il codice in sei file:

User.h: crea una gerarchia di utenti con una classe base User e due classi derivate: Student e Instructor.
La classe base User deve avere un nome e un ID, un metodo virtuale getRole() che restituisce il tipo di utente come stringa e un metodo getInfo() che restituisce "[name] ([id]) - [role]".

La classe Student tiene traccia degli ID dei corsi a cui è iscritto (usa un vettore di stringhe) e del numero di lezioni completate. Aggiungi i metodi enrollInCourse(const std::string& courseId), completedLesson() per incrementare il conteggio e getCompletedCount().

La classe Instructor memorizza una stringa che indica la specializzazione e tiene traccia degli ID dei corsi che insegna. Aggiungi addCourse(const std::string& courseId) e getSpecialty().
Lesson.h: crea una gerarchia di lezioni usando una classe base astratta.
La classe base Lesson deve avere un titolo e una durata (in minuti), un metodo virtuale puro complete() che restituisce un messaggio di completamento e un metodo getType() che restituisce il tipo di lezione.

Crea tre classi derivate:
- VideoLesson: ha un URL video. Il suo metodo complete() restituisce "Watched video: [title]"
- QuizLesson: ha un numero di domande. Il suo metodo complete() restituisce "Completed quiz: [title] ([questions] questions)"
- TextLesson: ha un conteggio di parole. Il suo metodo complete() restituisce "Read article: [title]"
Ognuna deve ridefinire getType() per restituire rispettivamente "Video", "Quiz" o "Text".
Course.h: crea una classe Course che possiede le proprie lezioni usando puntatori intelligenti.
Un corso ha un titolo, un ID e un ID dell'insegnante. Memorizza le lezioni come std::vector<std::unique_ptr<Lesson>>, poiché il corso ne detiene la proprietà esclusiva.

Aggiungi i metodi:
- addLesson(std::unique_ptr<Lesson> lesson): trasferisce la proprietà della lezione al corso
- getLessonCount(): restituisce il numero di lezioni
- getLesson(size_t index): restituisce un puntatore alla lezione in quell'indice (oppure nullptr se l'indice non è valido)
- displayCurriculum(): stampa il tipo e il titolo di ogni lezione nel formato "[index]. [Type]: [title]"
LessonFactory.h: implementa il pattern Factory per creare diversi tipi di lezione.
Crea una classe LessonFactory con un metodo statico createLesson(const std::string& type, const std::string& title, int duration, const std::string& extra) che restituisce un std::unique_ptr<Lesson>.

Il parametro type determina quale lezione creare ("video", "quiz" o "text"). Il parametro extra contiene dati specifici del tipo: URL per il video, numero di domande per il quiz (da convertire in int) oppure conteggio di parole per il testo (da convertire in int).
Platform.h: crea la classe centrale Platform che coordina ogni elemento.
Memorizza i corsi come std::vector<std::shared_ptr<Course>> e gli utenti come std::vector<std::shared_ptr<User>>.

Implementa:
- addCourse(std::shared_ptr<Course> course)
- addUser(std::shared_ptr<User> user)
- findCourse(const std::string& id): restituisce un shared_ptr oppure nullptr
- findUser(const std::string& id): restituisce un shared_ptr oppure nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId): trova entrambi, iscrive lo studente e stampa "Enrolled [name] in [course title]" oppure "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex): trova lo studente e il corso, chiama il metodo complete() della lezione, incrementa il conteggio delle lezioni completate dello studente e stampa il messaggio di completamento oppure "Could not complete lesson"
main.cpp: metti insieme tutti gli elementi per mostrare la tua piattaforma.
Leggi quattro input:
1. Nome della piattaforma
2. Dettagli del corso (formato: title,courseId,instructorId)
3. Dettagli dello studente (formato: name,studentId)
4. Lezione da aggiungere (formato: type,title,duration,extra)
Crea la piattaforma e visualizza "Welcome to [platform name]!". Crea il corso e lo studente e aggiungili alla piattaforma. Usa LessonFactory per creare la lezione e aggiungerla al corso. Visualizza il programma del corso. Iscrivi lo studente al corso. Completa la prima lezione (indice 0) per quello studente. Infine, stampa le informazioni dello studente e il numero di lezioni completate nel formato "Completed lessons: [count]".

Ad esempio, con gli input CodeAcademy, C++ Mastery,CPP101,I001, Alice,S001 e 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

Con gli input LearnHub, Python Basics,PY100,I002, Bob,S002 e 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

Questa sfida mostra come sono strutturate le vere piattaforme di e-learning, con una chiara separazione tra utenti, contenuti e piattaforma che li coordina. Il pattern Factory rende flessibile la creazione delle lezioni, i puntatori intelligenti garantiscono una gestione sicura della memoria e il polimorfismo permette di trattare tutti i tipi di lezione in modo uniforme, pur consentendo a ciascuno di comportarsi in modo specifico.

Provalo tu

#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() {
    // Leggi gli input
    std::string platformName;
    std::getline(std::cin, platformName);
    
    std::string courseDetails; // formato: title,courseId,instructorId
    std::getline(std::cin, courseDetails);
    
    std::string studentDetails; // formato: name,studentId
    std::getline(std::cin, studentDetails);
    
    std::string lessonDetails; // formato: type,title,duration,extra
    std::getline(std::cin, lessonDetails);
    
    // TODO: Analizza courseDetails per estrarre title, courseId, instructorId
    
    // TODO: Analizza studentDetails per estrarre name, studentId
    
    // TODO: Analizza lessonDetails per estrarre type, title, duration, extra
    
    // TODO: Crea la piattaforma e visualizza "Welcome to [platform name]!"
    
    // TODO: Crea il corso e lo studente e aggiungili alla piattaforma
    
    // TODO: Usa LessonFactory per creare la lezione e aggiungerla al corso
    
    // TODO: Visualizza il programma del corso
    
    // TODO: Iscrivi lo studente al corso
    
    // TODO: Completa la prima lezione (indice 0) per lo studente
    
    // TODO: Stampa le informazioni dello studente e il numero di lezioni completate
    // Formato: "Completed lessons: [count]"
    
    return 0;
}