From 276f239ad4455514c83d7e5f3857670937bad9e5 Mon Sep 17 00:00:00 2001 From: Steffen Vogel Date: Tue, 18 Oct 2011 21:53:59 +0200 Subject: [PATCH] Aufgabe 4 & 5 --- Aufgabenblock_2/AktivesVO.cpp | 49 ++++++++ Aufgabenblock_2/AktivesVO.h | 35 ++++++ Aufgabenblock_2/Fahrrad.cpp | 28 +++++ Aufgabenblock_2/Fahrrad.h | 17 +++ Aufgabenblock_2/Fahrzeug.cpp | 97 +++++++++++++++ Aufgabenblock_2/Fahrzeug.h | 44 +++++++ Aufgabenblock_2/FzgVerhalten.cpp | 28 +++++ Aufgabenblock_2/FzgVerhalten.h | 18 +++ Aufgabenblock_2/PKW.cpp | 75 ++++++++++++ Aufgabenblock_2/PKW.h | 35 ++++++ Aufgabenblock_2/Weg.cpp | 50 ++++++++ Aufgabenblock_2/Weg.h | 38 ++++++ Aufgabenblock_2/main.cpp | 197 +++++++++++++++++++++++++++++++ 13 files changed, 711 insertions(+) create mode 100644 Aufgabenblock_2/AktivesVO.cpp create mode 100644 Aufgabenblock_2/AktivesVO.h create mode 100644 Aufgabenblock_2/Fahrrad.cpp create mode 100644 Aufgabenblock_2/Fahrrad.h create mode 100644 Aufgabenblock_2/Fahrzeug.cpp create mode 100644 Aufgabenblock_2/Fahrzeug.h create mode 100644 Aufgabenblock_2/FzgVerhalten.cpp create mode 100644 Aufgabenblock_2/FzgVerhalten.h create mode 100644 Aufgabenblock_2/PKW.cpp create mode 100644 Aufgabenblock_2/PKW.h create mode 100644 Aufgabenblock_2/Weg.cpp create mode 100644 Aufgabenblock_2/Weg.h create mode 100644 Aufgabenblock_2/main.cpp diff --git a/Aufgabenblock_2/AktivesVO.cpp b/Aufgabenblock_2/AktivesVO.cpp new file mode 100644 index 0000000..c70b01b --- /dev/null +++ b/Aufgabenblock_2/AktivesVO.cpp @@ -0,0 +1,49 @@ +#include +#include + +#include "AktivesVO.h" + +int AktivesVO::p_iMaxID = 0; + +AktivesVO::AktivesVO() { + vInitialisierung(); +} + +AktivesVO::AktivesVO(string sName) { + vInitialisierung(); + + p_sName = sName; +} + +AktivesVO::AktivesVO(AktivesVO &vo) { + vInitialisierung(); + + p_sName = vo.p_sName; +} + +AktivesVO::~AktivesVO() { +} + +void AktivesVO::vInitialisierung() { + p_iID = ++p_iMaxID; + + p_sName = ""; + p_dZeit = 0; +} + +ostream& AktivesVO::ostreamAusgabe(ostream &stream) const { + stream << setprecision(2) << setiosflags(ios::fixed) + << resetiosflags(ios::right) << setiosflags(ios::left) + << setw(4) << p_iID + << setw(7) << p_sName << ":"; + + return stream; +} + +string AktivesVO::getName() const { + return p_sName; +} + +ostream& operator<<(ostream &stream, const AktivesVO &vo) { + return vo.ostreamAusgabe(stream); +} diff --git a/Aufgabenblock_2/AktivesVO.h b/Aufgabenblock_2/AktivesVO.h new file mode 100644 index 0000000..f74b985 --- /dev/null +++ b/Aufgabenblock_2/AktivesVO.h @@ -0,0 +1,35 @@ +#ifndef AKTIVESVO_H_ +#define AKTIVESVO_H_ + +#include + +using namespace std; + +class AktivesVO { +public: + AktivesVO(); + AktivesVO(AktivesVO &vo); + AktivesVO(string sName); + virtual ~AktivesVO(); + + virtual ostream& ostreamAusgabe(ostream &stream) const; + virtual void vAbfertigung() = 0; /* AktivesVO ist eine abstrakte Klasse */ + + string getName() const; + +protected: + double p_dZeit; + + /* nicht virtuell, da virtuelle Funktionen nicht + * in Konstruktoren aufgerufen werden dürfen!!! */ + void vInitialisierung(); + +private: + static int p_iMaxID; + int p_iID; + string p_sName; +}; + +ostream& operator<<(ostream &out, const AktivesVO &vo); + +#endif /* AKTIVESVO_H_ */ diff --git a/Aufgabenblock_2/Fahrrad.cpp b/Aufgabenblock_2/Fahrrad.cpp new file mode 100644 index 0000000..61260a4 --- /dev/null +++ b/Aufgabenblock_2/Fahrrad.cpp @@ -0,0 +1,28 @@ +#include + +#include "Fahrrad.h" + +/* Standardkonstruktor */ +Fahrrad::Fahrrad() : Fahrzeug() +{ } + +Fahrrad::Fahrrad(string sName, double dMaxGeschwindigkeit) : Fahrzeug(sName, dMaxGeschwindigkeit) +{ } + +/* Destruktor */ +Fahrrad::~Fahrrad() +{ } + +double Fahrrad::dGeschwindigkeit() const { + double dGeschwindigkeit; + int iReduzierung = p_dGesamtStrecke / 20; + + dGeschwindigkeit = p_dMaxGeschwindigkeit * powl(0.9, iReduzierung); + + if (dGeschwindigkeit < 12) { + dGeschwindigkeit = 12; + } + + return dGeschwindigkeit; +} + diff --git a/Aufgabenblock_2/Fahrrad.h b/Aufgabenblock_2/Fahrrad.h new file mode 100644 index 0000000..4853d87 --- /dev/null +++ b/Aufgabenblock_2/Fahrrad.h @@ -0,0 +1,17 @@ +#ifndef FAHRRAD_H_ +#define FAHRRAD_H_ + +#include "Fahrzeug.h" + +using namespace std; + +class Fahrrad: public Fahrzeug { +public: + Fahrrad(); + Fahrrad(string sName, double dMaxGeschwindigkeit); + virtual ~Fahrrad(); + + double dGeschwindigkeit() const; +}; + +#endif /* FAHRRAD_H_ */ diff --git a/Aufgabenblock_2/Fahrzeug.cpp b/Aufgabenblock_2/Fahrzeug.cpp new file mode 100644 index 0000000..72dd0bc --- /dev/null +++ b/Aufgabenblock_2/Fahrzeug.cpp @@ -0,0 +1,97 @@ +#include +#include +#include + +#include "Fahrzeug.h" +#include "Weg.h" +#include "AktivesVO.h" + +extern double dGlobaleZeit; + +/* Standardkonstruktor */ +Fahrzeug::Fahrzeug() : AktivesVO() +{ + vInitialisierung(); +} + +Fahrzeug::Fahrzeug(string sName) : AktivesVO(sName) +{ + vInitialisierung(); +} + +Fahrzeug::Fahrzeug(string sName, double dMaxGeschwindkeit) : AktivesVO(sName) +{ + vInitialisierung(); + p_dMaxGeschwindigkeit = dMaxGeschwindkeit; +} + +/* Kopierkonstruktor */ +Fahrzeug::Fahrzeug(Fahrzeug &fz) : AktivesVO(fz) +{ + vInitialisierung(); + p_dMaxGeschwindigkeit = fz.p_dMaxGeschwindigkeit; +} + +/* Destruktor */ +Fahrzeug::~Fahrzeug() +{ } + +void Fahrzeug::vInitialisierung() { + p_dMaxGeschwindigkeit = 0; + p_dGesamtStrecke = 0; + p_dAbschnittStrecke = 0; + p_dGesamtZeit = 0; + p_pVerhalten = NULL; +} + +void Fahrzeug::vAusgabeHeader() { + cout << "ID Name : MaxKmh GesamtStrecke Verbrauch Tankinhalt" << endl; + cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl; +} + +ostream& Fahrzeug::ostreamAusgabe(ostream &stream) const { + AktivesVO::ostreamAusgabe(stream) << resetiosflags(ios::left) << setiosflags(ios::right) + << setw(8) << dGeschwindigkeit() + << setw(7) << p_dGesamtStrecke + << " (" << setw(6) << p_dAbschnittStrecke << ")"; + + return stream; +} + +void Fahrzeug::vAbfertigung() { + /* nicht doppelt abfertigen (Gleitkommavgl.) */ + if (fabs(p_dZeit - dGlobaleZeit) < 1e-10) return; + + double dDelta = dGlobaleZeit - p_dZeit; + double dStrecke = p_pVerhalten->dStrecke(this, dDelta); + + p_dGesamtZeit += dDelta; + p_dGesamtStrecke += dStrecke; + p_dAbschnittStrecke += dStrecke; + p_dZeit = dGlobaleZeit; +} + +double Fahrzeug::dGeschwindigkeit() const { + return p_dMaxGeschwindigkeit; +} + +double Fahrzeug::dTanken(double dMenge) { + return 0; +} + +void Fahrzeug::vNeueStrecke(Weg *pWeg) { + if (p_pVerhalten != NULL) { /* alter Weg vorhanden? */ + delete p_pVerhalten; /* Speicherleck vermeiden! */ + } + else { + p_pVerhalten = new FzgVerhalten(pWeg); + } +} + +double Fahrzeug::getAbschnittStrecke() const { + return p_dAbschnittStrecke; +} + +bool Fahrzeug::operator<(Fahrzeug &fz) const { + return (this->p_dGesamtStrecke < fz.p_dGesamtStrecke); +} diff --git a/Aufgabenblock_2/Fahrzeug.h b/Aufgabenblock_2/Fahrzeug.h new file mode 100644 index 0000000..4269902 --- /dev/null +++ b/Aufgabenblock_2/Fahrzeug.h @@ -0,0 +1,44 @@ +#ifndef FAHRZEUG_H_ +#define FAHRZEUG_H_ + +#include "AktivesVO.h" +#include "FzgVerhalten.h" + +using namespace std; + +class Weg; + +class Fahrzeug : public AktivesVO { +public: + Fahrzeug(); + Fahrzeug(Fahrzeug &fz); /* Kopier Konstruktor */ + Fahrzeug(string sName); + Fahrzeug(string sName, double dMaxGeschwindkeit); + + virtual ~Fahrzeug(); /* Destruktor */ + + virtual void vAbfertigung(); + virtual double dTanken(double dMenge = 0.0); + virtual double dGeschwindigkeit() const; + void vNeueStrecke(Weg *pWeg); + + double getAbschnittStrecke() const; + + bool operator<(Fahrzeug &fz) const; + //Fahrzeug & operator=(Fahrzeug &fz); /* benutze Standardzuweisungs Operator */ + + static void vAusgabeHeader(); + virtual ostream& ostreamAusgabe(ostream &stream) const; + +protected: + double p_dMaxGeschwindigkeit; + double p_dGesamtStrecke; + double p_dGesamtZeit; + double p_dAbschnittStrecke; + FzgVerhalten * p_pVerhalten; + +private: + void vInitialisierung(); +}; + +#endif /* FAHRZEUG_H_ */ diff --git a/Aufgabenblock_2/FzgVerhalten.cpp b/Aufgabenblock_2/FzgVerhalten.cpp new file mode 100644 index 0000000..a926a1b --- /dev/null +++ b/Aufgabenblock_2/FzgVerhalten.cpp @@ -0,0 +1,28 @@ +#include + +#include "FzgVerhalten.h" +#include "Fahrzeug.h" + +extern double dGlobaleZeit; + +FzgVerhalten::FzgVerhalten(Weg *pWeg) { + p_pWeg = pWeg; +} + +/* Destruktor */ +FzgVerhalten::~FzgVerhalten() +{ } + +double FzgVerhalten::dStrecke(Fahrzeug *pFz, double dDelta) { + double dStrecke = pFz->dGeschwindigkeit() * dDelta; + + if (pFz->getAbschnittStrecke() >= p_pWeg->getLaenge()) { /* bereits zuweit gefahren */ + exit(0); + } + else if (pFz->getAbschnittStrecke() + dStrecke > p_pWeg->getLaenge()) { /* fahre nur bis zum Streckenende */ + return p_pWeg->getLaenge() - pFz->getAbschnittStrecke(); + } + else { /* fahre maximal mögliche Strecke */ + return dStrecke; + } +} diff --git a/Aufgabenblock_2/FzgVerhalten.h b/Aufgabenblock_2/FzgVerhalten.h new file mode 100644 index 0000000..bc6c3c9 --- /dev/null +++ b/Aufgabenblock_2/FzgVerhalten.h @@ -0,0 +1,18 @@ +#ifndef FZGVERHALTEN_H_ +#define FZGVERHALTEN_H_ + +#include "Weg.h" + +class FzgVerhalten { +public: + FzgVerhalten(Weg *pWeg); + virtual ~FzgVerhalten(); + + double dStrecke(Fahrzeug *pFz, double dZeit); + +private: + Weg * p_pWeg; + +}; + +#endif /* FZGVERHALTEN_H_ */ diff --git a/Aufgabenblock_2/PKW.cpp b/Aufgabenblock_2/PKW.cpp new file mode 100644 index 0000000..b68627f --- /dev/null +++ b/Aufgabenblock_2/PKW.cpp @@ -0,0 +1,75 @@ +#include +#include + +#include "PKW.h" + +using namespace std; + +extern double dGlobaleZeit; + +/* Standardkonstruktor */ +PKW::PKW() : + Fahrzeug(), + p_dVerbrauch(0), + p_dTankinhalt(0), + p_dTankvolumen(0) +{ } + +PKW::PKW(string sName, double dMaxGeschwindigkeit) : + Fahrzeug(sName, dMaxGeschwindigkeit), + p_dVerbrauch(0), + p_dTankinhalt(0), + p_dTankvolumen(0) +{ } + +PKW::PKW(string sName, double dMaxGeschwindigkeit, double dVerbrauch, double dTankvolumen) : + Fahrzeug(sName, dMaxGeschwindigkeit), + p_dVerbrauch(dVerbrauch), + p_dTankinhalt(dTankvolumen / 2), + p_dTankvolumen(dTankvolumen) +{ } + +/* Destruktor */ +PKW::~PKW() +{ } + +double PKW::dTanken(double dMenge) { + double dAlterInhalt = p_dTankinhalt; + + if (dMenge == 0) { + p_dTankinhalt = p_dTankvolumen; + } else { + p_dTankinhalt += dMenge; + if (p_dTankinhalt > p_dTankvolumen) { + p_dTankinhalt = p_dTankvolumen; /* Verhindere Überfüllung */ + } + } + + return p_dTankinhalt - dAlterInhalt; +} + +void PKW::vAbfertigung() { + if (p_dTankinhalt > 0) { /* prüfen, ob etwas im Tank ist */ + p_dTankinhalt -= (dGlobaleZeit - p_dZeit) * p_dMaxGeschwindigkeit + * p_dVerbrauch / 100; + + if (p_dTankinhalt < 0) { /* falls Tankinhalt negativ ist */ + p_dTankinhalt = 0; + } + + Fahrzeug::vAbfertigung(); + } +} + +ostream& PKW::ostreamAusgabe(ostream &stream) const { + Fahrzeug::ostreamAusgabe(stream) << setprecision(2) << setiosflags(ios::fixed) + << resetiosflags(ios::left) << setiosflags(ios::right) + << setw(12) << dVerbrauch() + << setw(13) << p_dTankinhalt; + + return stream; +} + +double PKW::dVerbrauch() const { + return p_dGesamtStrecke * p_dVerbrauch / 100; +} diff --git a/Aufgabenblock_2/PKW.h b/Aufgabenblock_2/PKW.h new file mode 100644 index 0000000..069fe13 --- /dev/null +++ b/Aufgabenblock_2/PKW.h @@ -0,0 +1,35 @@ +/* + * PKW.h + * + * Created on: 18.08.2011 + * Author: stv0g + */ + +#ifndef PKW_H_ +#define PKW_H_ + +#include + +#include "Fahrzeug.h" + +using namespace std; + +class PKW: public Fahrzeug { +public: + PKW(); + PKW(string sName, double dMaxGeschwindigkeit); + PKW(string sName, double dMaxGeschwindigkeit, double dVerbrauch, double dTankvolumen = 55); + virtual ~PKW(); + + void vAbfertigung(); + ostream& ostreamAusgabe(ostream &stream) const; + double dVerbrauch() const; + double dTanken(double dMenge = 0.0); + +private: + double p_dVerbrauch; + double p_dTankinhalt; + double p_dTankvolumen; +}; + +#endif /* PKW_H_ */ diff --git a/Aufgabenblock_2/Weg.cpp b/Aufgabenblock_2/Weg.cpp new file mode 100644 index 0000000..6454154 --- /dev/null +++ b/Aufgabenblock_2/Weg.cpp @@ -0,0 +1,50 @@ +#include +#include + +#include "Weg.h" +#include "Fahrzeug.h" + +/* Standardkonstruktor */ +Weg::Weg() : AktivesVO() +{ } + +Weg::Weg(string sName, double dLaenge, Begrenzung eLimit) : AktivesVO(sName) +{ + p_dLaenge = dLaenge; + p_eLimit = eLimit; +} + +/* Destruktor */ +Weg::~Weg() +{ } + +/* fertige alle Fahrzeuge auf Weg ab */ +void Weg::vAbfertigung() { + list::const_iterator iterator; + for (iterator = p_pFahrzeuge.begin(); iterator != p_pFahrzeuge.end(); ++iterator) { + (*iterator)->vAbfertigung(); + } +} + +void Weg::vAnnahme(Fahrzeug *pFz) { + pFz->vNeueStrecke(this); + p_pFahrzeuge.push_back(pFz); +} + +double Weg::getLaenge() const { + return p_dLaenge; +} + +ostream& Weg::ostreamAusgabe(ostream &stream) const { + AktivesVO::ostreamAusgabe(stream) << resetiosflags(ios::left) << setiosflags(ios::right) + << setw(24) << p_dLaenge << " ( "; + + list::const_iterator iterator; + for (iterator = p_pFahrzeuge.begin(); iterator != p_pFahrzeuge.end(); ++iterator) { + stream << (*iterator)->getName() << " "; + } + + stream << ")"; + + return stream; +} diff --git a/Aufgabenblock_2/Weg.h b/Aufgabenblock_2/Weg.h new file mode 100644 index 0000000..5f81c2c --- /dev/null +++ b/Aufgabenblock_2/Weg.h @@ -0,0 +1,38 @@ +#ifndef WEG_H_ +#define WEG_H_ + +#include +#include + +#include "AktivesVO.h" + +using namespace std; + +class Fahrzeug; /* Forward Deklaration */ + +typedef enum { + Innerorts, /* 50 km/h */ + Landstrasse, /* 100 km/h */ + Autobahn /* unbegrenzt */ +} Begrenzung; + +class Weg : public AktivesVO { +public: + Weg(); + Weg(string sName, double dLaenge, Begrenzung eLimit = Autobahn); + virtual ~Weg(); + + void vAbfertigung(); + void vAnnahme(Fahrzeug *pFz); + + double getLaenge() const; + + ostream& ostreamAusgabe(ostream &stream) const; + +private: + double p_dLaenge; + Begrenzung p_eLimit; + list p_pFahrzeuge; +}; + +#endif /* WEG_H_ */ diff --git a/Aufgabenblock_2/main.cpp b/Aufgabenblock_2/main.cpp new file mode 100644 index 0000000..6a0cb92 --- /dev/null +++ b/Aufgabenblock_2/main.cpp @@ -0,0 +1,197 @@ +#include +#include +#include + +#include "Fahrzeug.h" +#include "Fahrrad.h" +#include "PKW.h" +#include "Weg.h" + +using namespace std; + +double dGlobaleZeit = 0.0; + +void vAufgabe1() { + /* 3. Initialisieren */ + Fahrzeug fz1("Porsche"); + Fahrzeug *fz2 = new Fahrzeug(); + + string name; + cout << "Bitte geben Sie einen Fahrzeugnamen ein: "; + cin >> name; + + Fahrzeug *fz3 = new Fahrzeug(name, 22.5); + + Fahrzeug::vAusgabeHeader(); + cout << fz1 << endl << *fz2 << endl << *fz3 << endl; + + /* 9. Abfertigung */ + double dAbfertigungsIntervall; + cout << endl << "Bitte geben Sie ein Abfertigungsintervall ein: "; + cin >> dAbfertigungsIntervall; + + Fahrzeug::vAusgabeHeader(); + for ( ; dGlobaleZeit < 24; dGlobaleZeit += dAbfertigungsIntervall) { /* simuliere für einen Tag */ + fz1.vAbfertigung(); + fz2->vAbfertigung(); + fz3->vAbfertigung(); + + cout << endl << "globale Zeit: " << dGlobaleZeit; + cout << fz1 << endl << *fz2 << endl << *fz3 << endl; + } + + delete fz2; + delete fz3; +} + +/** + * Testing debugger + */ +void vAufgabe1_deb() { + Fahrzeug fz1("Opel"); + Fahrzeug fz2("Benz"); + Fahrzeug fz3("Ferrari"); + Fahrzeug fz4("Mini"); + + Fahrzeug *feld_name[4] = {&fz1, &fz2, &fz3, &fz4}; + + feld_name[2] = 0; // NULL pointer => Segmention Fault + + for (int i = 0; i < 4; i++) { + cout << *feld_name[i] << endl; + } +} + +void vAufgabe2() { + int iPKWs, iFahrraeder; + vector fahrzeuge; + + /* Erzeugen */ + + cout << "Wie viele PKWs möchten Sie erstellen? "; + cin >> iPKWs; + + cout << "Wie viele Fahrräder möchten Sie erstellen? "; + cin >> iFahrraeder; + + for (int i = 0; i < iPKWs + iFahrraeder; i++) { + Fahrzeug *fahrzeug; + string sName; + double dMaxGeschwindkeit; + + cout << "Bitte geben Sie den Namen des Fahrzeugs Nr. " << i+1 << " an: "; + cin >> sName; + cout << "Bitte geben Sie die maximale Geschwindkeit des Fahrzeugs Nr. " << i+1 << " an: "; + cin >> dMaxGeschwindkeit; + + if (i < iPKWs) { /* erzeuge PKW */ + double dVerbrauch; + cout << "Bitte geben Sie den Verbrauch des PKWs Nr. " << i+1 << " an: "; + cin >> dVerbrauch; + + fahrzeug = new PKW(sName, dMaxGeschwindkeit, dVerbrauch); + } + else { /* erzeuge Fahrrad */ + fahrzeug = new Fahrrad(sName, dMaxGeschwindkeit); + } + + fahrzeuge.push_back(fahrzeug); + } + + /* Abfertigen */ + + double dAbfertigungsIntervall; + size_t iNachgetankt = 0; + cout << "Bitte geben Sie ein Abfertigungsintervall ein: "; + cin >> dAbfertigungsIntervall; + cout << endl; + + Fahrzeug::vAusgabeHeader(); + + for ( ; dGlobaleZeit < 6; dGlobaleZeit += dAbfertigungsIntervall) { + vector::iterator it; + for (it = fahrzeuge.begin(); it != fahrzeuge.end(); it++) { + if (dGlobaleZeit > 3 && iNachgetankt < fahrzeuge.size()) { + (*it)->dTanken(); + iNachgetankt++; + } + + (*it)->vAbfertigung(); + cout << **it << endl; + } + } +} + +void vAufgabe3() { + PKW vw("Golf", 200, 6.7, 88); + Fahrrad velo("Haibike", 22); + Fahrzeug boat("Schiff", 11); + + dGlobaleZeit += 1.0; + velo.vAbfertigung(); + + Fahrzeug::vAusgabeHeader(); + cout << vw << endl << velo << endl << boat << endl << endl; + + if (vw < velo) { + cout << "Das Fahrrad ist bereits weiter gefahren"; + } + else { + cout << "Der Golf ist bereits weiter gefahren"; + } + + cout << endl << endl; + + Fahrrad veloKopie = velo; /* benutze Kopier Konstrukutor */ + Fahrrad veloKopie2; + + veloKopie2 = velo; /* benutze Zuweisungsoperator */ + + Fahrzeug::vAusgabeHeader(); + cout << veloKopie << endl << veloKopie2 << endl; +} + +void vAufgabe4() { + Weg weg("Allee", 15.0, Landstrasse); + PKW vw("Golf", 120, 6.7, 88); + Fahrrad velo("Haibike", 22); + + weg.vAnnahme(&vw); + weg.vAnnahme(&velo); + + Fahrzeug::vAusgabeHeader(); + while (1) { + dGlobaleZeit += 1.0/60; + weg.vAbfertigung(); + cout << vw << endl << velo << endl << weg << endl << "Globale Zeit: " << dGlobaleZeit << endl; + } +} + +int main() { + int iWahl; + + retry: + + cout << "1: vAufgabe1()" << endl; + cout << "0: vAufgabe1_deb()" << endl; + cout << "2: vAufgabe2()" << endl; + cout << "3: vAufgabe3()" << endl; + cout << "4: vAufgabe4()" << endl; + cout << "Bitte wähen Sie eine Aufgabe: "; + cin >> iWahl; + cout << endl; + + switch (iWahl) { + case 1: vAufgabe1(); break; + case 0: vAufgabe1_deb(); break; + case 2: vAufgabe2(); break; + case 3: vAufgabe3(); break; + case 4: vAufgabe4(); break; + default: + cerr << "Ungültige Eingabe! Bitte versuchen Sie es erneut" << endl; + goto retry; + } + + cout << endl; + return 0; +}