Aufgabe 4 & 5

This commit is contained in:
Steffen Vogel 2011-10-18 21:53:59 +02:00
parent 0644adfb29
commit 276f239ad4
13 changed files with 711 additions and 0 deletions

View file

@ -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);
}

View file

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

View file

@ -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;
}

17
Aufgabenblock_2/Fahrrad.h Normal file
View file

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

View file

@ -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);
}

View file

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

View file

@ -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;
}
}

View file

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

75
Aufgabenblock_2/PKW.cpp Normal file
View file

@ -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;
}

35
Aufgabenblock_2/PKW.h Normal file
View file

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

50
Aufgabenblock_2/Weg.cpp Normal file
View file

@ -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;
}

38
Aufgabenblock_2/Weg.h Normal file
View file

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

197
Aufgabenblock_2/main.cpp Normal file
View file

@ -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;
}