E-Learning-Plattform

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 103 von 104.

Aufgabe

Einfach

Erstellen wir eine E-Learning-Plattform, die alle OOP-Konzepte zusammenführt, die du im Laufe dieses Kurses gemeistert hast. Du erstellst ein System, das Kurse und verschiedene Arten von Lektionen verwaltet und den Lernfortschritt der Studierenden verfolgt: Dabei werden Vererbungshierarchien, Polymorphismus, Smart Pointer und Entwurfsmuster demonstriert, die harmonisch zusammenarbeiten.

Du organisierst deinen Code über sechs Dateien:

User.h: Erstelle eine Benutzerhierarchie mit einer Basisklasse User und zwei abgeleiteten Klassen: Student und Instructor.
Deine Basisklasse User sollte einen Namen und eine ID besitzen, mit einer virtuellen Methode getRole(), die den Benutzertyp als Zeichenkette zurückgibt, sowie einer Methode getInfo(), die "[name] ([id]) - [role]" zurückgibt.

Die Klasse Student verfolgt die IDs der belegten Kurse (verwende einen Vektor von Zeichenketten) und die Anzahl der abgeschlossenen Lektionen. Füge die Methoden enrollInCourse(const std::string& courseId), completedLesson() zum Erhöhen des Zählers und getCompletedCount() hinzu.

Die Klasse Instructor speichert eine Zeichenkette für das Fachgebiet und verfolgt die IDs der von der Person unterrichteten Kurse. Füge addCourse(const std::string& courseId) und getSpecialty() hinzu.
Lesson.h: Baue eine Lektionenhierarchie mithilfe einer abstrakten Basisklasse auf.
Deine Basisklasse Lesson sollte einen Titel und eine Dauer (in Minuten) besitzen, mit einer rein virtuellen Methode complete(), die eine Abschlussmeldung zurückgibt, sowie einer Methode getType(), die den Lektionstyp zurückgibt.

Erstelle drei abgeleitete Klassen:
- VideoLesson: Besitzt eine Video-URL. complete() gibt "Watched video: [title]" zurück.
- QuizLesson: Besitzt eine Anzahl von Fragen. complete() gibt "Completed quiz: [title] ([questions] questions)" zurück.
- TextLesson: Besitzt eine Wortanzahl. complete() gibt "Read article: [title]" zurück.
Jede Klasse sollte getType() überschreiben, um jeweils "Video", "Quiz" oder "Text" zurückzugeben.
Course.h: Erstelle eine Klasse Course, die ihre Lektionen mithilfe von Smart Pointern besitzt.
Ein Kurs besitzt einen Titel, eine ID und eine Dozenten-ID. Speichere die Lektionen als std::vector<std::unique_ptr<Lesson>>, da der Kurs seine Lektionen exklusiv besitzt.

Füge folgende Methoden hinzu:
- addLesson(std::unique_ptr<Lesson> lesson): Überträgt den Besitz der Lektion an den Kurs.
- getLessonCount(): Gibt die Anzahl der Lektionen zurück.
- getLesson(size_t index): Gibt einen Zeiger auf die Lektion an diesem Index zurück (oder nullptr, wenn der Index ungültig ist).
- displayCurriculum(): Gibt den Typ und Titel jeder Lektion im Format "[index]. [Type]: [title]" aus.
LessonFactory.h: Implementiere das Factory-Muster, um verschiedene Lektionstypen zu erstellen.
Erstelle eine Klasse LessonFactory mit einer statischen Methode createLesson(const std::string& type, const std::string& title, int duration, const std::string& extra), die ein std::unique_ptr<Lesson> zurückgibt.

Der Parameter type bestimmt, welche Lektion erstellt wird ("video", "quiz" oder "text"). Der Parameter extra enthält typspezifische Daten: die URL für ein Video, die Anzahl der Fragen für ein Quiz (als int parsen) oder die Wortanzahl für einen Text (als int parsen).
Platform.h: Baue die zentrale Klasse Platform, die alles koordiniert.
Speichere die Kurse als std::vector<std::shared_ptr<Course>> und die Benutzer als std::vector<std::shared_ptr<User>>.

Implementiere:
- addCourse(std::shared_ptr<Course> course)
- addUser(std::shared_ptr<User> user)
- findCourse(const std::string& id): Gibt einen shared_ptr oder nullptr zurück.
- findUser(const std::string& id): Gibt einen shared_ptr oder nullptr zurück.
- enrollStudent(const std::string& studentId, const std::string& courseId): Findet beide, schreibt die Studentin bzw. den Studenten für den Kurs ein und gibt "Enrolled [name] in [course title]" oder "Enrollment failed" aus.
- completeLesson(const std::string& studentId, const std::string& courseId, size_t lessonIndex): Findet die Studentin bzw. den Studenten und den Kurs, ruft die Methode complete() der Lektion auf, erhöht die Anzahl der abgeschlossenen Lektionen der Studentin bzw. des Studenten und gibt die Abschlussmeldung oder "Could not complete lesson" aus.
main.cpp: Führe alles zusammen, um deine Plattform zu demonstrieren.
Lies vier Eingaben ein:
1. Name der Plattform
2. Kursdetails (Format: title,courseId,instructorId)
3. Details der Studentin bzw. des Studenten (Format: name,studentId)
4. Hinzuzufügende Lektion (Format: type,title,duration,extra)
Erstelle die Plattform und gib "Welcome to [platform name]!" aus. Erstelle den Kurs und die Studentin bzw. den Studenten und füge beide zur Plattform hinzu. Verwende die LessonFactory, um die Lektion zu erstellen, und füge sie dem Kurs hinzu. Gib den Kurslehrplan aus. Schreibe die Studentin bzw. den Studenten für den Kurs ein. Schließe die erste Lektion (Index 0) für diese Studentin bzw. diesen Studenten ab. Gib schließlich die Informationen der Studentin bzw. des Studenten sowie die Anzahl der abgeschlossenen Lektionen als "Completed lessons: [count]" aus.

Beispielsweise mit den Eingaben CodeAcademy, C++ Mastery,CPP101,I001, Alice,S001 und 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

Mit den Eingaben LearnHub, Python Basics,PY100,I002, Bob,S002 und 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

Diese Herausforderung zeigt, wie echte E-Learning-Plattformen strukturiert sind, mit einer klaren Trennung zwischen Benutzern, Inhalten und der Plattform, die sie koordiniert. Das Factory-Muster macht die Erstellung von Lektionen flexibel, Smart Pointer sorgen für eine sichere Speicherverwaltung, und Polymorphismus ermöglicht es dir, alle Lektionstypen einheitlich zu behandeln, während sich jeder Typ individuell verhält.

Probier es selbst

#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() {
    // Eingaben lesen
    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: Parse courseDetails, um title, courseId, instructorId zu extrahieren
    
    // TODO: Parse studentDetails, um name, studentId zu extrahieren
    
    // TODO: Parse lessonDetails, um type, title, duration, extra zu extrahieren
    
    // TODO: Erstelle die Platform und zeige "Welcome to [platform name]!" an
    
    // TODO: Erstelle den Course und den Student, füge sie zur Platform hinzu
    
    // TODO: Verwende LessonFactory, um die Lesson zu erstellen und sie zum Course hinzuzufügen
    
    // TODO: Zeige den Lehrplan des Course an
    
    // TODO: Schreibe den Student in den Course ein
    
    // TODO: Schließe die erste Lektion (Index 0) für den Studenten ab
    
    // TODO: Print the student's info and completed lesson count
    // Format: "Completed lessons: [count]"
    
    return 0;
}