Aufgabe 4 & 5

Aufgabenblock_2/AktivesVO.cpp

@@ -0,0 +1,49 @@
+#include <iostream>
+#include <iomanip>
+
+#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);
+}

Aufgabenblock_2/AktivesVO.h

@@ -0,0 +1,35 @@
+#ifndef AKTIVESVO_H_
+#define AKTIVESVO_H_
+
+#include <string>
+
+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_ */

Aufgabenblock_2/Fahrrad.cpp

@@ -0,0 +1,28 @@
+#include <math.h>
+
+#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;
+}
+

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_ */

Aufgabenblock_2/Fahrzeug.cpp

@@ -0,0 +1,97 @@
+#include <iostream>
+#include <iomanip>
+#include <cmath>
+
+#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);
+}

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_ */

Aufgabenblock_2/FzgVerhalten.cpp

@@ -0,0 +1,28 @@
+#include <stdlib.h>
+
+#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;
+	}
+}

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_ */

Aufgabenblock_2/PKW.cpp

@@ -0,0 +1,75 @@
+#include <iostream>
+#include <iomanip>
+
+#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;
+}

Aufgabenblock_2/PKW.h

@@ -0,0 +1,35 @@
+/*
+ * PKW.h
+ *
+ *  Created on: 18.08.2011
+ *      Author: stv0g
+ */
+
+#ifndef PKW_H_
+#define PKW_H_
+
+#include <string>
+
+#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_ */

Aufgabenblock_2/Weg.cpp

@@ -0,0 +1,50 @@
+#include <iostream>
+#include <iomanip>
+
+#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<Fahrzeug *>::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<Fahrzeug *>::const_iterator iterator;
+	for (iterator = p_pFahrzeuge.begin(); iterator != p_pFahrzeuge.end(); ++iterator) {
+		stream << (*iterator)->getName() << " ";
+	}
+
+	stream << ")";
+
+	return stream;
+}

Aufgabenblock_2/Weg.h

@@ -0,0 +1,38 @@
+#ifndef WEG_H_
+#define WEG_H_
+
+#include <list>
+#include <string>
+
+#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<Fahrzeug *> p_pFahrzeuge;
+};
+
+#endif /* WEG_H_ */

Aufgabenblock_2/main.cpp

@@ -0,0 +1,197 @@
+#include <string>
+#include <vector>
+#include <iostream>
+
+#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<Fahrzeug *> 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<Fahrzeug *>::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;
+}