Plataforma de E-Learning

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

Vamos a construir una Plataforma de E-Learning que reúna todos los conceptos de POO que has dominado a lo largo de este curso. Crearás un sistema que gestiona cursos, diferentes tipos de lecciones y realiza un seguimiento del progreso de los estudiantes, demostrando jerarquías de herencia, polimorfismo, punteros inteligentes y patrones de diseño trabajando 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 e ID, con un método virtual getRole() que devuelva el tipo de usuario como un string, y un método getInfo() que devuelva "[name] ([id]) - [role]".

La clase Student realiza un seguimiento de los IDs de los cursos inscritos (usa un vector de strings) y el recuento de lecciones completadas. Añade los métodos enrollInCourse(const std::string& courseId), completedLesson() para incrementar el recuento, y getCompletedCount().

La clase Instructor almacena un string de especialidad y realiza un seguimiento de los IDs de los cursos que imparte. Añade addCourse(const std::string& courseId) y getSpecialty().
Lesson.h: Construye una jerarquía de lecciones utilizando una clase base abstracta.
Tu clase base Lesson debe tener un título y una duración (en minutos), con 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 utilizando 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 posee sus lecciones exclusivamente.

Añade los 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() — imprime el tipo y el título de cada lección en el formato "[index]. [Type]: [title]"
LessonFactory.h: Implementa el patrón Factory para crear diferentes 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: URL para video, recuento de preguntas para quiz (convertir a int) o recuento de palabras para texto (convertir 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 shared_ptr o nullptr
- findUser(const std::string& id) — devuelve shared_ptr o nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId) — busca ambos, inscribe al estudiante, imprime "Enrolled [name] in [course title]" o "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex) — busca al estudiante y al curso, llama al método complete() de la lección, incrementa el recuento de lecciones completadas del estudiante, imprime el mensaje de finalización o "Could not complete lesson"
main.cpp: Reúne todo para demostrar 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 a añadir (formato: type,title,duration,extra)
Crea la plataforma y muestra "Welcome to [platform name]!". Crea el curso y el estudiante, añádelos a la plataforma. Usa el LessonFactory para crear la lección y añadirla al curso. Muestra el plan de estudios del curso. Inscribe al estudiante en el curso. Completa la primera lección (índice 0) para ese estudiante. Finalmente, imprime la información del estudiante y su recuento de lecciones completadas como "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 e-learning reales, con una separación clara entre usuarios, contenido y la plataforma que los coordina. El patrón Factory hace que la creación de lecciones sea flexible, los punteros inteligentes garantizan una gestión de memoria segura y el polimorfismo te permite tratar todos los tipos de lecciones de manera uniforme mientras cada una se comporta 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 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, agregarlos a la plataforma
    
    // TODO: Usar LessonFactory para crear la lección y agregarla al curso
    
    // TODO: Mostrar el plan de estudios del curso
    
    // TODO: Inscribir al estudiante en el curso
    
    // TODO: Completar la primera lección (índice 0) para el estudiante
    
    // TODO: Imprimir la información del estudiante y el recuento de lecciones completadas
    // Formato: "Completed lessons: [count]"
    
    return 0;
}