Plataforma de aprendizaje en línea

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 103 de 104.

Desafío

Fácil

Construyamos una plataforma de aprendizaje en línea que reúna todos los conceptos de POO que has dominado a lo largo de este curso. Crearás un sistema que administra cursos y distintos tipos de lecciones, y lleva un seguimiento del progreso de los estudiantes: demostrando cómo las jerarquías de herencia, el polimorfismo, los punteros inteligentes y los patrones de diseño funcionan en armonía.

Organizarás tu código en seis archivos:

User.h: Crea una jerarquía de usuarios con una clase base User y dos clases derivadas: Student e Instructor.
Tu clase base User debe tener un nombre y un ID, además de un método virtual getRole() que devuelva el tipo de usuario como una cadena, y un método getInfo() que devuelva "[name] ([id]) - [role]".

La clase Student lleva un registro de los ID de los cursos en los que está inscrito (usa un vector de cadenas) y del número de lecciones completadas. Añade los métodos enrollInCourse(const std::string& courseId), completedLesson() para incrementar el contador, y getCompletedCount().

La clase Instructor almacena una cadena con su especialidad y lleva un registro de los ID de los cursos que imparte. Añade addCourse(const std::string& courseId) y getSpecialty().
Lesson.h: Crea una jerarquía de lecciones usando una clase base abstracta.
Tu clase base Lesson debe tener un título y una duración (en minutos), además de un método virtual puro complete() que devuelva un mensaje de finalización, y un método getType() que devuelva el tipo de lección.

Crea tres clases derivadas:
- VideoLesson: Tiene una URL de video. Su método complete() devuelve "Watched video: [title]"
- QuizLesson: Tiene un número de preguntas. Su método complete() devuelve "Completed quiz: [title] ([questions] questions)"
- TextLesson: Tiene un recuento de palabras. Su método complete() devuelve "Read article: [title]"
Cada una debe sobrescribir getType() para devolver "Video", "Quiz" o "Text", respectivamente.
Course.h: Crea una clase Course que sea propietaria de sus lecciones mediante punteros inteligentes.
Un curso tiene un título, un ID y un ID de instructor. Almacena las lecciones como std::vector<std::unique_ptr<Lesson>>, ya que el curso es el único propietario de sus lecciones.

Añade estos métodos:
- addLesson(std::unique_ptr<Lesson> lesson): transfiere la propiedad de la lección al curso
- getLessonCount(): devuelve el número de lecciones
- getLesson(size_t index): devuelve un puntero a la lección en ese índice (o nullptr si no es válido)
- displayCurriculum(): muestra el tipo y el título de cada lección con el formato "[index]. [Type]: [title]"
LessonFactory.h: Implementa el patrón Factory para crear distintos tipos de lecciones.
Crea una clase LessonFactory con un método estático createLesson(const std::string& type, const std::string& title, int duration, const std::string& extra) que devuelva un std::unique_ptr<Lesson>.

El parámetro type determina qué lección crear ("video", "quiz" o "text"). El parámetro extra contiene datos específicos del tipo: la URL para video, el número de preguntas para quiz (convertido a int) o el recuento de palabras para texto (convertido a int).
Platform.h: Construye la clase central Platform que coordina todo.
Almacena los cursos como std::vector<std::shared_ptr<Course>> y los usuarios como std::vector<std::shared_ptr<User>>.

Implementa:
- addCourse(std::shared_ptr<Course> course)
- addUser(std::shared_ptr<User> user)
- findCourse(const std::string& id): devuelve un shared_ptr o nullptr
- findUser(const std::string& id): devuelve un shared_ptr o nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId): busca ambos, inscribe al estudiante y muestra "Enrolled [name] in [course title]" o "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex): busca al estudiante y el curso, llama al método complete() de la lección, incrementa el recuento de lecciones completadas del estudiante y muestra el mensaje de finalización o "Could not complete lesson"
main.cpp: Reúne todo para mostrar cómo funciona tu plataforma.
Lee cuatro entradas:
1. Nombre de la plataforma
2. Detalles del curso (formato: title,courseId,instructorId)
3. Detalles del estudiante (formato: name,studentId)
4. Lección que se añadirá (formato: type,title,duration,extra)
Crea la plataforma y muestra "Welcome to [platform name]!". Crea el curso y el estudiante, y añádelos a la plataforma. Usa LessonFactory para crear la lección y añadirla al curso. Muestra el currículo del curso. Inscribe al estudiante en el curso. Completa la primera lección (índice 0) para ese estudiante. Por último, muestra la información del estudiante y su recuento de lecciones completadas con el formato "Completed lessons: [count]".

Por ejemplo, con las entradas CodeAcademy, C++ Mastery,CPP101,I001, Alice,S001 y 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 las entradas LearnHub, Python Basics,PY100,I002, Bob,S002 y 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

Este desafío demuestra cómo se estructuran las plataformas de aprendizaje en línea reales, con una separación clara entre los usuarios, el contenido y la plataforma que los coordina. El patrón Factory hace flexible la creación de lecciones, los punteros inteligentes garantizan una gestión segura de la memoria y el polimorfismo permite tratar todos los tipos de lecciones de manera uniforme, aunque cada uno se comporte de forma única.

Pruébalo tú mismo

#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() {
    // Leer las entradas
    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: Analizar courseDetails para extraer title, courseId, instructorId
    
    // TODO: Analizar studentDetails para extraer name, studentId
    
    // TODO: Analizar lessonDetails para extraer type, title, duration, extra
    
    // TODO: Crear la plataforma y mostrar "Welcome to [platform name]!"
    
    // TODO: Crear el curso y el estudiante, y añadirlos a la plataforma
    
    // TODO: Usar LessonFactory para crear la lección y añadirla al curso
    
    // TODO: Mostrar el plan de estudios del curso
    
    // TODO: Inscribir al estudiante en el curso
    
    // TODO: Completa la primera lección (índice 0) para el estudiante
    
    // TODO: Imprime la información del estudiante y el número de lecciones completadas
    // Formato: "Completed lessons: [count]"
    
    return 0;
}