Platforma e-learningowa

Część sekcji Programowanie obiektowe ścieżki C++ w Coddy. Lekcja 103 z 104.

Wyzwanie

Łatwy

Zbudujmy platformę e-learningową, która łączy wszystkie koncepcje OOP opanowane przez Ciebie w trakcie tego kursu. Stworzysz system zarządzający kursami i różnymi typami lekcji oraz śledzący postępy uczniów, demonstrujący współdziałanie hierarchii dziedziczenia, polimorfizmu, inteligentnych wskaźników i wzorców projektowych.

Rozmieścisz swój kod w sześciu plikach:

User.h: Utwórz hierarchię użytkowników z bazową klasą User i dwiema klasami pochodnymi: Student oraz Instructor.
Twoja bazowa klasa User powinna zawierać imię i identyfikator, wirtualną metodę getRole(), która zwraca typ użytkownika jako ciąg znaków, oraz metodę getInfo(), która zwraca "[name] ([id]) - [role]".

Klasa Student śledzi identyfikatory zapisanych kursów (użyj wektora ciągów znaków) oraz liczbę ukończonych lekcji. Dodaj metody enrollInCourse(const std::string& courseId), completedLesson() do zwiększania licznika oraz getCompletedCount().

Klasa Instructor przechowuje ciąg znaków określający specjalizację i śledzi identyfikatory prowadzonych kursów. Dodaj metody addCourse(const std::string& courseId) i getSpecialty().
Lesson.h: Zbuduj hierarchię lekcji, używając abstrakcyjnej klasy bazowej.
Twoja bazowa klasa Lesson powinna zawierać tytuł i czas trwania (w minutach), czysto wirtualną metodę complete(), która zwraca komunikat o ukończeniu, oraz metodę getType(), która zwraca typ lekcji.

Utwórz trzy klasy pochodne:
- VideoLesson: Zawiera URL filmu. Jej metoda complete() zwraca "Watched video: [title]"
- QuizLesson: Zawiera liczbę pytań. Jej metoda complete() zwraca "Completed quiz: [title] ([questions] questions)"
- TextLesson: Zawiera liczbę słów. Jej metoda complete() zwraca "Read article: [title]"
Każda z nich powinna nadpisywać metodę getType(), zwracając odpowiednio "Video", "Quiz" lub "Text".
Course.h: Utwórz klasę Course, która zarządza swoimi lekcjami za pomocą inteligentnych wskaźników.
Kurs ma tytuł, identyfikator oraz identyfikator instruktora. Przechowuj lekcje jako std::vector<std::unique_ptr<Lesson>>, ponieważ kurs jest ich wyłącznym właścicielem.

Dodaj metody:
- addLesson(std::unique_ptr<Lesson> lesson): przenosi własność lekcji na kurs
- getLessonCount(): zwraca liczbę lekcji
- getLesson(size_t index): zwraca wskaźnik do lekcji o podanym indeksie (lub nullptr, jeśli indeks jest nieprawidłowy)
- displayCurriculum(): wyświetla typ i tytuł każdej lekcji w formacie "[index]. [Type]: [title]"
LessonFactory.h: Zaimplementuj wzorzec Fabryki, aby tworzyć różne typy lekcji.
Utwórz klasę LessonFactory ze statyczną metodą createLesson(const std::string& type, const std::string& title, int duration, const std::string& extra), która zwraca std::unique_ptr<Lesson>.

Parametr type określa, którą lekcję utworzyć ("video", "quiz" lub "text"). Parametr extra zawiera dane właściwe dla danego typu: URL filmu, liczbę pytań w quizie (przekształć na int) lub liczbę słów w lekcji tekstowej (przekształć na int).
Platform.h: Zbuduj centralną klasę Platform, która koordynuje wszystkie elementy.
Przechowuj kursy jako std::vector<std::shared_ptr<Course>>, a użytkowników jako std::vector<std::shared_ptr<User>>.

Zaimplementuj:
- addCourse(std::shared_ptr<Course> course)
- addUser(std::shared_ptr<User> user)
- findCourse(const std::string& id): zwraca shared_ptr lub nullptr
- findUser(const std::string& id): zwraca shared_ptr lub nullptr
- enrollStudent(const std::string& studentId, const std::string& courseId): wyszukuje oba elementy, zapisuje ucznia na kurs i wyświetla "Enrolled [name] in [course title]" lub "Enrollment failed"
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex): wyszukuje ucznia i kurs, wywołuje metodę complete() lekcji, zwiększa licznik ukończonych lekcji ucznia i wyświetla komunikat o ukończeniu lub "Could not complete lesson"
main.cpp: Połącz wszystkie elementy, aby zaprezentować działanie platformy.
Wczytaj cztery dane wejściowe:
1. Nazwę platformy
2. Szczegóły kursu (format: title,courseId,instructorId)
3. Szczegóły ucznia (format: name,studentId)
4. Dodawaną lekcję (format: type,title,duration,extra)
Utwórz platformę i wyświetl "Welcome to [platform name]!". Utwórz kurs i ucznia, a następnie dodaj ich do platformy. Użyj LessonFactory, aby utworzyć lekcję i dodać ją do kursu. Wyświetl program kursu. Zapisz ucznia na kurs. Ukończ pierwszą lekcję (indeks 0) przez tego ucznia. Na koniec wyświetl informacje o uczniu oraz liczbę ukończonych przez niego lekcji w formacie "Completed lessons: [count]".

Na przykład dla danych wejściowych CodeAcademy, C++ Mastery,CPP101,I001, Alice,S001 i 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

Dla danych wejściowych LearnHub, Python Basics,PY100,I002, Bob,S002 i 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

To wyzwanie pokazuje, jak są zbudowane rzeczywiste platformy e-learningowe, z wyraźnym podziałem na użytkowników, treści i koordynującą je platformę. Wzorzec Fabryki uelastycznia tworzenie lekcji, inteligentne wskaźniki zapewniają bezpieczne zarządzanie pamięcią, a polimorfizm pozwala traktować wszystkie typy lekcji jednolicie, mimo że każdy z nich zachowuje się inaczej.

Spróbuj swoich sił

#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() {
    // Odczytaj dane wejściowe
    std::string platformName;
    std::getline(std::cin, platformName);
    
    std::string courseDetails; // format: title,courseId,instructorId
    std::getline(std::cin, courseDetails);
    
    std::string studentDetails; // format: name,studentId
    std::getline(std::cin, studentDetails);
    
    std::string lessonDetails; // format: type,title,duration,extra
    std::getline(std::cin, lessonDetails);
    
    // TODO: Przeanalizuj courseDetails, aby wyodrębnić title, courseId, instructorId
    
    // TODO: Przeanalizuj studentDetails, aby wyodrębnić name, studentId
    
    // TODO: Przeanalizuj lessonDetails, aby wyodrębnić type, title, duration, extra
    
    // TODO: Utwórz platformę i wyświetl "Welcome to [platform name]!"
    
    // TODO: Utwórz kurs i studenta, a następnie dodaj ich do platformy
    
    // TODO: Użyj LessonFactory, aby utworzyć lekcję i dodać ją do kursu
    
    // TODO: Wyświetl program kursu
    
    // TODO: Zapisz studenta na kurs
    
    // TODO: Oznacz pierwszą lekcję (indeks 0) jako ukończoną przez ucznia
    
    // TODO: Wyświetl informacje o uczniu i liczbę ukończonych lekcji
    // Format: "Completed lessons: [count]"
    
    return 0;
}