Plataforma de E-Learning

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 103 de 104.

Desafio

Fácil

Vamos construir uma Plataforma de E-Learning que reúna todos os conceitos de POO que você dominou ao longo deste curso. Você criará um sistema que gerencia cursos, diferentes tipos de lições e acompanha o progresso dos alunos — demonstrando hierarquias de herança, polimorfismo, ponteiros inteligentes e padrões de projeto trabalhando em harmonia.

Você organizará seu código em seis arquivos:

User.h: Crie uma hierarquia de usuários com uma classe base User e duas classes derivadas: Student e Instructor.
Sua classe base User deve ter um nome e ID, com um método virtual getRole() que retorna o tipo de usuário como uma string, e um método getInfo() que retorna "[name] ([id]) - [role]".

A classe Student rastreia os IDs dos cursos matriculados (use um vector de strings) e a contagem de lições concluídas. Adicione os métodos enrollInCourse(const std::string& courseId), completedLesson() para incrementar a contagem, e getCompletedCount().

A classe Instructor armazena uma string de especialidade e rastreia os IDs dos cursos que leciona. Adicione addCourse(const std::string& courseId) e getSpecialty().
Lesson.h: Construa uma hierarquia de lições usando uma classe base abstrata.
Sua classe base Lesson deve ter um título e duração (em minutos), com um método virtual puro complete() que retorna uma mensagem de conclusão, e um método getType() que retorna o tipo da lição.

Crie três classes derivadas:
- VideoLesson: Possui uma URL de vídeo. Seu complete() retorna "Watched video: [title]"
- QuizLesson: Possui um número de questões. Seu complete() retorna "Completed quiz: [title] ([questions] questions)"
- TextLesson: Possui uma contagem de palavras. Seu complete() retorna "Read article: [title]"
Cada uma deve sobrescrever getType() para retornar "Video", "Quiz", ou "Text" respectivamente.
Course.h: Crie uma classe Course que possui suas lições usando ponteiros inteligentes.
Um curso tem um título, ID e ID do instrutor. Armazene as lições como std::vector<std::unique_ptr<Lesson>>, já que o curso possui suas lições exclusivamente.

Adicione os métodos:
- addLesson(std::unique_ptr<Lesson> lesson) — transfere a propriedade da lição para o curso
- getLessonCount() — retorna o número de lições
- getLesson(size_t index) — retorna um ponteiro para a lição naquele índice (ou nullptr se for inválido)
- displayCurriculum() — imprime o tipo e o título de cada lição no formato "[index]. [Type]: [title]"
LessonFactory.h: Implemente o padrão Factory para criar diferentes tipos de lições.
Crie uma classe LessonFactory com um método estático createLesson(const std::string& type, const std::string& title, int duration, const std::string& extra) que retorna um std::unique_ptr<Lesson>.

O parâmetro type determina qual lição criar ("video", "quiz", ou "text"). O parâmetro extra contém dados específicos do tipo: URL para vídeo, contagem de questões para quiz (converter para int), ou contagem de palavras para texto (converter para int).
Platform.h: Construa a classe central Platform que coordena tudo.
Armazene os cursos como std::vector<std::shared_ptr<Course>> e os usuários como std::vector<std::shared_ptr<User>>.

Implemente:
- addCourse(std::shared_ptr<Course> course)
- addUser(std::shared_ptr<User> user)
- findCourse(const std::string& id) — retorna shared_ptr ou nullptr
- findUser(const std::string& id) — retorna shared_ptr ou nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId) — encontra ambos, matricula o aluno, imprime "Enrolled [name] in [course title]" ou "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex) — encontra o aluno e o curso, chama o método complete() da lição, incrementa a contagem de concluídas do aluno, imprime a mensagem de conclusão ou "Could not complete lesson"
main.cpp: Reúna tudo para demonstrar sua plataforma.
Leia quatro entradas:
1. Nome da plataforma
2. Detalhes do curso (formato: title,courseId,instructorId)
3. Detalhes do aluno (formato: name,studentId)
4. Lição a ser adicionada (formato: type,title,duration,extra)
Crie a plataforma e exiba "Welcome to [platform name]!". Crie o curso e o aluno, adicione-os à plataforma. Use a LessonFactory para criar a lição e adicione-a ao curso. Exiba o currículo do curso. Matricule o aluno no curso. Conclua a primeira lição (índice 0) para esse aluno. Por fim, imprima as informações do aluno e sua contagem de lições concluídas como "Completed lessons: [count]".

Por exemplo, com as entradas 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

Com as entradas 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

Este desafio demonstra como as plataformas de e-learning reais são estruturadas — com uma separação clara entre usuários, conteúdo e a plataforma que os coordena. O padrão Factory torna a criação de lições flexível, os ponteiros inteligentes garantem o gerenciamento seguro da memória e o polimorfismo permite tratar todos os tipos de lições de forma uniforme, enquanto cada uma se comporta de maneira única.

Experimente você mesmo

#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() {
    // Ler as 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: Analisar courseDetails para extrair title, courseId, instructorId
    
    // TODO: Analisar studentDetails para extrair name, studentId
    
    // TODO: Analisar lessonDetails para extrair type, title, duration, extra
    
    // TODO: Criar a plataforma e exibir "Welcome to [platform name]!"
    
    // TODO: Criar o curso e o estudante, adicioná-los à plataforma
    
    // TODO: Usar LessonFactory para criar a lição e adicioná-la ao curso
    
    // TODO: Exibir o currículo do curso
    
    // TODO: Matricular o estudante no curso
    
    // TODO: Concluir a primeira lição (índice 0) para o estudante
    
    // TODO: Imprimir as informações do estudante e a contagem de lições concluídas
    // Formato: "Completed lessons: [count]"
    
    return 0;
}