Polymorphie

In dieser Aufgabe müssen UML Diagramme erstellt werden und eine Implementierung in C++ geschrieben werden.

Probeklausur SoSe 2023

In der folgenden Darstellung eines Klassendiagramms wird ein Ausschnitt aus einem Programm zur Verwaltung einer Bibliothek angezeigt. Jedes Buch hat spezielle Ausleihbedingungen, die die Ausleihgebühren bestimmen.

Probeklausur SoSe 2023

Die Methoden ausleihGebuehr und getAusleihZeitraum der jeweiligen Klassen sind wie folgt aufgebaut:

Buch: ausleihGebuehr = basisAusleihGebuehr * tage
- Ausleihzeitraum ist 2 Monate
Roman: ausleihGebuehr = basisAusleihGebuehr * tage
- Maximal 5 Euro
- Ausleihzeitraum ist 1 Monat
Fachbücher: Feste Gebühr von 2 Euro, unabhängig von der Ausleihdauer
- Ausleihzeitraum ist 2 Wochen

Stellen Sie mittels dynamischer Bindung sicher, dass die Methoden der zugehörigen Objekte verwendet werden, auch wenn auf Objekte der Unterklassen mittels Zeigern vom Typ der Oberklasse zugegriffen wird. Geben Sie eine Implementierung in C++ an, die die Klassen und Methoden entsprechend den Anforderungen implementiert.


#include <iostream>
#include <string>
 
class Buch {
    protected:
        string title;
        double basisAusleihGebuehr;
 
    public:
        Buch(const string& t, double basisAusleihGebuehr) : title(t), basisAusleihGebuehr(basisAusleihGebuehr) {}
 
        virtual ~Buch() {}
        virtual double ausleihGebuehr(int tage) {
            return basisAusleihGebuehr * tage;
        }
 
        virtual string getAusleihZeitraum() {
            return "2 Monate";
        }
};
 
class Roman : public Buch {
    public:
        Roman(const string& t, double basisAusleihGebuehr) : Buch(t, basisAusleihGebuehr) {}
 
        double ausleihGebuehr(int tage) override {
            double gebuehr = basisAusleihGebuehr * tage;
            if (gebuehr > 5.0) {
                return 5.0;
            }
            return gebuehr;
        }
 
        string getAusleihZeitraum() override {
            return "1 Monat";
        }
};
 
class Fachbuch : public Buch {
    public:
        Fachbuch(const string& t, double basisAusleihGebuehr) : Buch(t, basisAusleihGebuehr) {}
 
        double ausleihGebuehr(int tage) override {
            return 2.0;
        }
 
        string getAusleihZeitraum() override {
            return "2 Wochen";
        }
};

PE2 SoSe 2023

Im folgenden Klassendiagramm ist ein Ausschnitt einer Zoo-Verwaltungssoftware gezeigt. Jedes Tier hat spezielle Fütterungsanforderungen, die den Verbrauch bestimmen.

PE2 SoSe 2023

Die Methode verbrauch und getFuetterungszeit der jeweiligen Klassen gestalten sich wie folgt:

Säugetier: verbrauch = gewicht ∗tagesration ∗tage
- Fütterungszeit ist Mittags
Reptilen erhalten nur für alle vollen 7 Tage jeweils
- 10 ∗ tagesration ∗ gewicht
- Bei weniger als 7 Tagen, erhalten Reptilien keine Essensration.
- Fütterungszeit ist Nachts

Stellen Sie mittels dynamischer Bindung sicher, dass die Methoden der zugehörigen Objekte verwendet werden, auch wenn auf Objekte der Unterklassen mittels Zeigern vom Typ der Oberklasse zugegriffen wird. Geben Sie eine Implementierung in C++ an, die die Klassen samt Methoden entsprechend der Anforderungen implementiert.


#include <iostream>
#include <string>
 
using namespace std;
 
class Tier {
    protected:
        double gewicht;
        double tagesration;
 
    public:
        Tier(double gw, double tr) : gewicht(gw), tagesration(tr) {}
 
        virtual ~Tier() {}
        virtual double verbrauch(int tage) {
            return 0.0;
        };
 
        virtual string getFuetterungszeit() {
            return "";
        };
}
 
class Saeugetier : public Tier {
    public:
        Saeugetier(double gw, double tr) : Tier(gw, tr) {}
 
        double verbrauch(int tage) override {
            return gewicht * tagesration * tage;
        }
 
        string getFuetterungszeit() override {
            return "Mittags";
        }
}
 
class Reptil : public Tier {
    public:
        Reptil(double gw, double tr) : Tier(gw, tr) {}
 
        double verbrauch(int tage) override {
            int anzahlRationen = tage / 7;
            return anzahlRationen * (10 * tagesration * gewicht);
        }
 
        string getFuetterungszeit() override {
            return "Nachts";
        }
}

PE2 WiSe 2023

In der folgenden Aufgabe soll ein System für die Produktverwaltung in einem E-Commerce-Portal entworfen werden, das verschiedene Arten von Produkten verkauft. Das Ziel ist es, ein System zu schaffen, das leicht um neue Produkttypen, in Form von abgeleiteten Klassen, erweitert werden kann, ohne bestehende Schnittstellen zu ändern. Dies sind die Anforderungen:

Abstrakte Klasse Produkt
- Enthält gemeinse Eigenschaften für alle abgeleiteten Klassen:
  - id (int), beschreibung (string), preis (double)
  - Definiert eine Methode berechneLieferkosten(), die standardmäßig einen festen Betrag zurückgibt.
  - Definiert eine virtuelle Methode info(), die spezifische Informationen für verschiedene Produkttypen liefert.
Abgeleitete Klassen:
- Buch:
  - Enthält die zusätzlichen Attribute:
    - autor (string), isbn10 (string)
- Elektronik:
  - Enthält die zusätzlichen Attribute:
    - garantiezeit (int), energieklasse (char)
Klasse ISBN:
- Speichert eine ISBN-Nummer als string
- Gibt diese via getNummer() zurück

Teilaufgaben

Skizzieren Sie ein entsprechendes, vollständiges UML-Klassendiagramm unter Berücksichtigung der obigen Anforderungen. Berücksichtigen Sie alle getroffenen Spezifikationen, genannten Klassen, Methoden, Attribute und skizzieren alle Klassenbeziehungen.
Geben Sie eine Implementierung in C++ an, die die abstrakte Basisklasse, die Klasse Buch und die Klasse ISBN samt Methoden entsprechend der obigen Anforderungen implementiert. Die Ausgabe von info() soll jeweils die allgemeinen und produkttyp-spezifischen Attribute ausgeben.

Teilaufgabe 2


#include <iostream>
#include <string>
 
using namespace std;
 
class ISBN {
    private:
        string nummer;
 
    public:
        ISBN(const string& n) : nummer(n) {}
 
        string getNummer() const {
            return nummer;
        }
}
 
class Produkt {
    protected:
        int id;
        string beschreibung;
        double preis;
 
    public:
        Produkt(int id, const string& beschreibung, double preis) : id(id), beschreibung(beschreibung), preis(preis) {}
 
        virtual ~Produkt() {}
        
        virtual double berechneLieferkosten() const {
            return 5.0;
        }
 
        virtual void info() const = 0;
}
 
class Buch : public Produkt {
    private:
        string autor;
        ISBN isbn;
 
    public:
        Buch(int id, const string& beschreibung, double preis, const string& autor, const ISBN& isbn) : Produkt(id, beschreibung, preis), autor(autor), isbn(isbn) {}
 
        void info() const override {
            cout << "Produkt ID: " << id << ", Beschreibung: " << beschreibung << ", Preis: " << preis << ", Autor: " << autor << ", ISBN: " << isbn.getNummer() << endl;
        }
}
 
class Elektronik : public Produkt {
    private:
        int garantiezeit;
        char energieklasse;
 
    public:
        Elektronik(int id, const string& beschreibung, double preis, int garantiezeit, char energieklasse) : Produkt(id, beschreibung, preis), garantiezeit(garantiezeit), energieklasse(energieklasse) {}
 
        void info() const override {
            cout << "Produkt ID: " << id << ", Beschreibung: " << beschreibung << ", Preis: " << preis << ", Garantiezeit: " << garantiezeit << ", Energieklasse: " << energieklasse << endl;
        }
}

PE2 SoSe 2024

Ziel der Aufgabe ist die Entwicklung eines Systems zur Verwaltung verschiedener Arten von Events bzw. Veranstaltungsterminen. Das System soll einfach um neue Veranstaltungstypen erweitert werden können und unterschiedliche Teilnahme und Preisgestaltungsstrategien ermöglichen. Dies sind die Anforderungen:

Abstrakte Basisklasse Event
- Gemeinsame Eigenschaften für alle Events:
  - id (int), name (string), datum (string)
  - Die ID soll für jedes Event einzigartig sein und automatisch beim Konstruktoraufruf gesetzt werden. Beim ersten erzeugten Objekt der abgeleiteten Klassen beginnt die ID mit 1 und wird bei jedem weiteren Objekt um jeweils 1 erhöht.
  - Eine dynamisch gebundene Methode info() (string), die Name und Datum des Events zurückliefert.
  - Eine abstrakte Methode getPreis(), die die Teilnahmegebühr basierend auf dem Eventtyp berechnet und zurückgibt.
Abgeleitete Klassen:
- Webinar
  - Enthält die zusätzlichen Attribute:
    - thema (string), dauer (int)
- Workshop
  - Enthält die zusätzlichen Attribute:
    - leiter (string), teilnehmerLimit (int)
- Konzert
  - Enthält die zusätzlichen Attribute:
    - kuenstler (string), genre (string)
Eine Klasse Person zum Speichern und Zurückgeben des Namens der Person

Treffen Sie bei unvollständigen Informationen sinnvolle Annahmen und wählen Sie, falls notwendig, geeignete Beispielwerte.

Teilaufgaben

Skizzieren Sie ein vollständiges UML-Klassendiagramm unter Berücksichtigung der obigen Anforderungen. Berücksichtigen Sie alle getroffenen Spezifikationen, genannten Klassen, Methoden, Attribute und skizzieren alle Klassenbeziehungen.
Geben Sie (ausschließlich) für die abstrakte Basisklasse und die Klasse für Konzert eine Implementierung in C++ an, die die obigen Anforderungen realisiert. Die Methode info() soll in Konzert überschrieben werden und zusätzlich den Namen der Person sowie das Genre ausgeben.
Schreiben Sie einen Komponententest (UnitTest), der die korrekte Realisierung der dynamischen Bindung für die Methode info() für Konzert sicherstellt, wenn über einen Zeiger vom Typ Event auf das Objekt zugegriffen wird.

Teilaufgabe 2


#include <iostream>
#include <string>
 
using namespace std;
 
class Person {
    private:
        string name;
 
    public:
        Person(const string& n) : name(n) {}
 
        string getName() const {
            return name;
        }
}
 
class Event {
    private:
        static int nextId;
 
    protected:
        int id;
        string name;
        string datum;
 
        void setId() {
            id = ++nextId;
        }
 
    public:
        Event(const string& n, const string& d) : id(nextId++), name(n), datum(d) {
            setId();
        }
 
        virtual ~Event() {}
 
        virtual string info() const {
            return "Event ID: " + to_string(id) + ", Name: " + name + ", Datum: " + datum;
        }
 
        virtual double getPreis() const = 0;
}
 
int Event::nextId = 0;
 
class Konzert : public Event {
    private:
        Person kuenstler;
        string genre;
 
    public:
        Konzert(const string& n, const string& d, const Person& k, const string& g)
            : Event(n, d), kuenstler(k), genre(g) {}
 
        string info() const override {
            return Event::info() + ", Künstler: " + kuenstler.getName() + ", Genre: " + genre;
        }
 
        double getPreis() const override {
            return 20.0;
        }
}

Teilaufgabe 3


#include <iostream>
#include <cassert>
#include <string>
 
// Annahme: Die Klassen Event, Person und Konzert sind bereits definiert
void testDynamicBinding() {
    // Arrange
    Person kuenstler("Max Mustermann");
    Event* eventPtr = new Konzert("Sommerfest", "2024-06-15", kuenstler, "Rock");
    
    // Act
    string result = eventPtr->info();
    
    // Assert
    string expected = "Event ID: 1, Name: Sommerfest, Datum: 2024-06-15, Künstler: Max Mustermann, Genre: Rock";
    assert(result == expected && "Dynamische Bindung für info() funktioniert nicht korrekt!");
    
    // Cleanup
    delete eventPtr;
    
    cout << "Test erfolgreich: Dynamische Bindung für info() funktioniert wie erwartet." << endl;
}
 
int main() {
    // Zurücksetzen der statischen ID für konsistente Tests
    Event::nextId = 0;
    
    testDynamicBinding();
    return 0;
}