Fehlersuche

Jede Klausur startet mit einer Fehlersuche. Hier wird ein Codeausschnit gegeben und dieser kann einen oder mehrere Fehler enthalten. Der Fehler muss dann durchs markieren der Fehlerstellen gelöst werden.

Probeklausur SoSe 2023

Aufgabe 1:

Gegeben sei das folgende C++-Programm, das eine vereinfachte Version der Addition von Brüchen (ohne Kürzen) mittels Operatorüberladung realisieren soll:

Erwartete Ausgabe: 5/6


#include <iostream>
class Bruch {
    private:
        int _zaehler;
        int _nenner;
    public:
        Bruch(int zaehler, int nenner): _zaehler(zaehler), _nenner(nenner) {
            if (_nenner == 0) {
                throw std::invalid_argument("Nenner darf nicht 0 sein");
            }
        }
 
        Bruch add(const Bruch& x) {
            return Bruch(_zaehler + x._zaehler, _nenner + x._nenner);
        }
 
        // Operator + überladen
        // const = keine Änderung der Objekte
        // Anpassung der Rechnung
        Bruch operator+(const Bruch& x) const {
            return Bruch(_zaehler * x._nenner + x._zaehler * _nenner, 
                _nenner * x._nenner);
        }
        
        void print() {
            std::cout << _zaehler << "/" << _nenner << std::endl;
        }
 
};
 
int main() {
    try {
        Bruch f1(1, 2);
        Bruch f2(1, 3);
        Bruch f3 = f1 + f2;
        f3.print();
    } catch (const std::exception& e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}

Aufgabe 2:

Erwartete Ausgabe: Marke: Tesla, Kilometerstand: 100


#include <iostream>
#include <string>
 
class Auto {
    private:
        std::string marke;
        int kilometerstand;
 
    protected:
        Auto(std::string m, int k): marke(m), kilometerstand(k) {}
 
    // protected -> public
    public:
        Auto(std::string m, int k): marke(m), kilometerstand(k) {}
 
    // Kilometerstand wird modifiziert
    void fahre(int km) const {
    void fahre(int km) {
        kilometerstand += km;
    }
 
 
    std::string getMarke() {
        return marke;
    }
 
    int getKilometerstand() {
        return kilometerstand;
    }
};
 
int main() {
    Auto meinAuto("Tesla", 0);
    meinAuto.fahre(100);
    std::cout << "Marke: " << meinAuto.getMarke() << ", Kilometerstand: " << meinAuto.getKilometerstand() << std::endl;
    return 0;
}

PE2 SoSe 2023

Aufgabe 1:

Gegeben sei das folgende C++-Programm, das in einem Videospiel den Gesundheitsstatus (health) von Charakteren (Helden/Hero und Monstern) berechnet:

Erwartete Ausgabe: Monster Health: 50


#include <iostream>
 
class Character {
    private:
        int health;
        Character(int h) : health(h) {}
        int getHealth () { return health; }
        void setHealth(int h) { health = h; }
 
    private:
        int health;
 
    protected:
        Character(int h) : health(h) {}
        void setHealth(int h) { health = h; }
 
    public:
        int getHealth () { return health; }
};
 
class Hero : public Character {
    public:
        Hero(int h) : Character(h) {}
 
    void attack(Character m) { m.setHealth(m.getHealth () - 50); }
    void attack(Character& m) { m.setHealth(m.getHealth () - 50); }
};
 
class Monster : public Character {
    public:
        Monster(int h) : Character(h) {}
};
 
int main() {
    Hero hero(100);
    Monster monster(100);
 
    hero.attack(monster);
    std::cout << "Monster Health: " << monster.getHealth () << std::endl;
    return 0;
}

Aufgabe 2:

Die gegeben Klassen sollen zu folgendem Programmabschnitt (der selbst keinen Fehler beinhaltet) kompatibel sein, enthalten jedoch Fehler:


Musikinstrument* instrument1 = new Gitarre();
Musikinstrument* instrument2 = new Schlagzeug();
instrument1 ->spiel();
instrument2 ->spiel();

Hierfür ist die erwartete Ausgabe:


Gitarre spielt: Gitarrensound
Schlagzeug spielt: Schlagzeugsound


#include <iostream >
#include <string >
using namespace std;
 
class Musikinstrument {
    public:
        string name;
        Musikinstrument(string n) : name(n) {}
        void spiel() { // Ermöglicht die Überschreibung der Methode in den Unterklassen
        virtual void spiel () {
            cout << name << " spielt: " << "Unbekannter Ton" << endl;
        }
};
 
// Gitarre muss von Musikinstrument erben
class Gitarre {
class Gitarre : public Musikinstrument {
    public:
        Gitarre() : Musikinstrument("Gitarre") {}
        void spiel() { // Überschreibt die Methode in der Basisklasse
        void spiel() override {
            cout << name << " spielt: " << "Gitarrensound" << endl;
        }
}; 
 
// Schlagzeug muss von Musikinstrument erben
class Schlagzeug {
class Schlagzeug : public Musikinstrument {
    public:
        Schlagzeug() : Musikinstrument("Schlagzeug") {}
        void spiel() { // Überschreibt die Methode in der Basisklasse
        void spiel() override {
            cout << name << " spielt: " << "Schlagzeugsound" << endl;
        }
};

PE2 WiSe 2023

Gegeben sei der folgende Code für die Klassenhierarchie von Fahrzeugen, der einen oder mehrere Fehler beinhalten, und die erwartete Ausgabe. Finden und korrigieren Sie den oder die Fehler direkt im Codeausschnitt oder als Freitext unter Angabe der entsprechenden Zeilennummern

Erwartete Ausgabe:


Auto Geschwindigkeit: 10
Motorrad Geschwindigkeit: 20


#include <iostream>
#include <string>
 
class Fahrzeug {
    private:
        std:: string typ;
        int geschwindigkeit;
 
    public:
        int get_geschwindigkeit () { return geschwindigkeit; };
        Fahrzeug(std:: string t) : typ(t), geschwindigkeit (0) {}
        void beschleunige(int kmh) {
            geschwindigkeit += kmh;
        }
};
 
class Auto : Fahrzeug { // Fehlender Zugriffsmodifizierer
class Auto : public Fahrzeug {
    public:
        Auto() : Fahrzeug("Auto") {}
        void beschleunige() {
            geschwindigkeit += 10; // Fehler: geschwindigkeit ist private
            Fahrzeug::beschleunige(10);
        }
};
 
class Motorrad : Fahrzeug { // Fehlender Zugriffsmodifizierer
class Motorrad : public Fahrzeug { 
    public:
        Motorrad() : Fahrzeug("Motorrad") {}
        void beschleunige() {
            geschwindigkeit += 20; // Fehler: geschwindigkeit ist private
            Fahrzeug::beschleunige(20);
        }
};
 
int main() {
    Auto car;
    Motorrad motorrad;
    car->beschleunige(); // Fehler: car ist ein Objekt, kein Zeiger
    car.beschleunige();
    motorrad->beschleunige(); // Fehler: motorrad ist ein Objekt, kein Zeiger
    motorrad.beschleunige();
    std::cout << "Auto Geschwindigkeit: " << car.get_geschwindigkeit() << std::endl;
    std::cout << "Motorrad Geschwindigkeit: " << motorrad.get_geschwindigkeit () << std::endl;
    return 0;
}

PE2 SoSe 2024

Gegeben sei der folgende Code für die Klassenhierarchie von Eingabegeräten, der einen oder mehrere Fehler beinhaltet, und die erwartete Ausgabe. Finden und korrigieren Sie den oder die Fehler direkt im Codeausschnitt oder als Freitext unter Angabe der entsprechenden Zeilennummern.

Erwartete Ausgabe:


Tastatur-ID: 10
Maus-ID: 20


#include <iostream>
#include <string>
 
class Eingabegeraet {
    private:
        int id;
        std::string bezeichnung;
 
    public:
        int get_id() { return id; };
        Eingabegeraet(std::string bez) : id(0), bezeichnung(bez) {}
        void increment_id(int offset) {
            id + offset; // Fehler: Der Offset wird nicht der ID zugewiesen
            id += offset;
        }
};
 
class Tastatur : public Eingabegeraet {
    private: // Falscher Zugriffsmodifizierer
    public:
        Tastatur() : Eingabegeraet ("Tastatur") {}
        void increment_id() {
            id + 10; // Fehler: id ist private
            Eingabegeraet::increment_id(10);
        }
};
 
class Maus: public Eingabegeraet {
    private: // Falscher Zugriffsmodifizierer
    public:
        Maus() : Eingabegeraet ("Maus") {}
        void increment_id() {
            id + 20; // Fehler: id ist private
            Eingabegeraet::increment_id(20);
        }
};
 
int main() {
    Tastatur tastatur;
    Maus maus;
    tastatur.increment_id();
    maus.increment_id();
    std::cout << "Tastatur -ID: " << tastatur.get_id() << std::endl;
    std::cout << "Maus -ID: " << maus.get_id() << std::endl;
    return 0;
}

Tipps

Bei diesen Aufgaben kommen häufiger die selben Fehler vor. Daher lohnt es sich auf die folgenden Fehler zu konzentrieren:

Falscher Zugriffsmodifizierer (private anstatt protected oder public)
Konstruktorparameter falsch benannt
const wird falsch verwendet
- Wenn eine Methode als const deklariert wird, bedeutet das, dass sie keine Variablen verändern kann.
Operatorüberladung (Wenn +, -, *, / als Rechnung verwendet werden und kein operator vorhanden ist)
Referenzen und Zeiger verwechselt
- Wenn nur eine Kopie modifiziert werden soll, muss eine Referenz (&) verwendet werden.
Fehlendes public bei der Vererbung
this vergessen? Wenn z.B. in private und public die selbe Variable verwendet wird.
Falscher Pointer-Syntax (z.B. -> statt .)
- -> wenn das Objekt ein Pointer ist
- . wenn das Objekt ein Objekt ist