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

Construyamos una plataforma de aprendizaje electrónico que reúna todos los conceptos de OOP que has dominado a lo largo de este curso. Crearás un sistema que administra cursos y distintos 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 y Instructor.
Tu clase base User debe tener un nombre y un ID, con 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 realiza un seguimiento de los ID de los cursos inscritos (usa un vector de cadenas) y de la cantidad de lecciones completadas. Añade los métodos enrollInCourse(const std::string& courseId), completedLesson() para incrementar la cantidad y getCompletedCount().

La clase Instructor almacena una cadena con la especialidad y realiza un seguimiento de los ID de los cursos que imparte. Añade addCourse(const std::string& courseId) y getSpecialty().
Lesson.h: Construye 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), 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 una cantidad 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 los métodos:
- addLesson(std::unique_ptr<Lesson> lesson): transfiere la propiedad de la lección al curso
- getLessonCount(): devuelve la cantidad 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 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 el video, la cantidad de preguntas para el cuestionario (se analiza como int) o el recuento de palabras para el texto (se analiza como 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): encuentra ambos, inscribe al estudiante e imprime "Enrolled [name] in [course title]" o "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex): encuentra al estudiante y el curso, llama al método complete() de la lección, incrementa la cantidad de lecciones completadas del estudiante e 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 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 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 cantidad 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 reales de aprendizaje electrónico, con una separación clara entre los usuarios, el 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 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() {
    // Lee 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: Analiza courseDetails para extraer title, courseId, instructorId
    
    // TODO: Analiza studentDetails para extraer name, studentId
    
    // TODO: Analiza lessonDetails para extraer type, title, duration, extra
    
    // TODO: Crea la plataforma y muestra "Welcome to [platform name]!"
    
    // TODO: Crea el curso y el estudiante, añádelos a la plataforma
    
    // TODO: Usa LessonFactory para crear la lección y añádela al curso
    
    // TODO: Muestra el plan de estudios del curso
    
    // TODO: Inscribe al estudiante en el curso
    
    // TODO: Completa la primera lección (índice 0) para el estudiante
    
    // TODO: Print the student's info and completed lesson count
    // Format: "Completed lessons: [count]"
    
    return 0;
}