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úne todos os conceitos de OOP que você aprendeu 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 um 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 acompanha os IDs dos cursos nos quais está matriculado (use um vetor de strings) e a quantidade 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 acompanha 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 uma 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: Tem uma URL de vídeo. Seu complete() retorna "Watched video: [title]"
- QuizLesson: Tem uma quantidade de perguntas. Seu complete() retorna "Completed quiz: [title] ([questions] questions)"
- TextLesson: Tem 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 seja proprietária de suas lições usando ponteiros inteligentes.
Um curso tem um título, um ID e um ID de 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, quantidade de perguntas para quiz (converta para int) ou contagem de palavras para texto (converta 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 e 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 lições concluídas do aluno e 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 adicionar (formato: type,title,duration,extra)
Crie a plataforma e exiba "Welcome to [platform name]!". Crie o curso e o aluno e adicione-os à plataforma. Use o LessonFactory para criar a lição e adicioná-la 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 a quantidade 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 plataformas reais de e-learning são estruturadas, com uma separação clara entre usuários, conteúdo e a plataforma que os coordena. O padrão Factory torna flexível a criação de lições, os ponteiros inteligentes garantem um gerenciamento seguro da memória e o polimorfismo permite tratar todos os tipos de lição de maneira uniforme, enquanto cada um se comporta de forma ú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 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: Complete a primeira lição (índice 0) para o estudante
    
    // TODO: Print the student's info and completed lesson count
    // Format: "Completed lessons: [count]"
    
    return 0;
}