stv0g/rwth-info3
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

bis Aufgabe 6

Browse source
This commit is contained in:
Steffen Vogel 2011-11-01 13:43:39 +01:00
parent 8e2e1d0f4e
commit fd481ab0d5
11 changed files with 134 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
Aufgabenblock_2/AktivesVO.cpp
View file

@ -3,6 +3,8 @@
#include "AktivesVO.h"
extern double dGlobaleZeit;
int AktivesVO::p_iMaxID = 0;
AktivesVO::AktivesVO() {
@ -31,9 +33,17 @@ void AktivesVO::vInitialisierung() {
p_dZeit = 0;
}
void AktivesVO::vAusgabeHeader() {
cout << "Zeit ID Name : Kmh GesamtStrecke Verbrauch Tankinhalt" << endl;
cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
<< endl;
}
ostream& AktivesVO::ostreamAusgabe(ostream &stream) const {
stream << setprecision(2) << setiosflags(ios::fixed)
stream << setprecision(1) << setiosflags(ios::fixed)
<< resetiosflags(ios::right) << setiosflags(ios::left)
<< setw(5) << dGlobaleZeit
//<< " (" << setw(3) << p_dZeit << ") "
<< setw(4) << p_iID
<< setw(7) << p_sName << ":";

2
Aufgabenblock_2/AktivesVO.h
View file

@ -12,7 +12,9 @@ public:
AktivesVO(string sName);
virtual ~AktivesVO();
static void vAusgabeHeader();
virtual ostream& ostreamAusgabe(ostream &stream) const;
virtual void vAbfertigung() = 0; /* AktivesVO ist eine abstrakte Klasse */
string getName() const;

59
Aufgabenblock_2/Fahrzeug.cpp
View file

@ -4,37 +4,39 @@
#include "Fahrzeug.h"
#include "Weg.h"
#include "FzgFahren.h"
#include "FzgParken.h"
#include "AktivesVO.h"
extern double dGlobaleZeit;
/* Standardkonstruktor */
Fahrzeug::Fahrzeug() : AktivesVO()
{
Fahrzeug::Fahrzeug() :
AktivesVO() {
vInitialisierung();
}
Fahrzeug::Fahrzeug(string sName) : AktivesVO(sName)
{
Fahrzeug::Fahrzeug(string sName) :
AktivesVO(sName) {
vInitialisierung();
}
Fahrzeug::Fahrzeug(string sName, double dMaxGeschwindkeit) : AktivesVO(sName)
{
Fahrzeug::Fahrzeug(string sName, double dMaxGeschwindkeit) :
AktivesVO(sName) {
vInitialisierung();
p_dMaxGeschwindigkeit = dMaxGeschwindkeit;
}
/* Kopierkonstruktor */
Fahrzeug::Fahrzeug(Fahrzeug &fz) : AktivesVO(fz)
{
Fahrzeug::Fahrzeug(Fahrzeug &fz) :
AktivesVO(fz) {
vInitialisierung();
p_dMaxGeschwindigkeit = fz.p_dMaxGeschwindigkeit;
}
/* Destruktor */
Fahrzeug::~Fahrzeug()
{ }
Fahrzeug::~Fahrzeug() {
}
void Fahrzeug::vInitialisierung() {
p_dMaxGeschwindigkeit = 0;
@ -44,23 +46,20 @@ void Fahrzeug::vInitialisierung() {
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 << ")";
AktivesVO::ostreamAusgabe(stream) << setprecision(2)
<< 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;
if (fabs(p_dZeit - dGlobaleZeit) < 1e-10)
return;
double dDelta = dGlobaleZeit - p_dZeit;
double dStrecke = p_pVerhalten->dStrecke(this, dDelta);
@ -72,20 +71,32 @@ void Fahrzeug::vAbfertigung() {
}
double Fahrzeug::dGeschwindigkeit() const {
return p_dMaxGeschwindigkeit;
double dBegrenzung = p_pVerhalten->getMaxgeschwindigkeit();
if (p_dMaxGeschwindigkeit > dBegrenzung) {
return dBegrenzung;
}
else {
return p_dMaxGeschwindigkeit;
}
}
double Fahrzeug::dTanken(double dMenge) {
return 0;
}
void Fahrzeug::vNeueStrecke(Weg *pWeg) {
void Fahrzeug::vNeueStrecke(Weg *pWeg, double dStartZeit) {
if (p_pVerhalten != NULL) { /* alter Weg vorhanden? */
delete p_pVerhalten; /* Speicherleck vermeiden! */
}
else {
p_pVerhalten = new FzgVerhalten(pWeg);
else if (dStartZeit > 0) {
p_pVerhalten = new FzgParken(pWeg, dStartZeit);
}
else {
p_pVerhalten = new FzgFahren(pWeg);
}
p_dAbschnittStrecke = 0;
}
double Fahrzeug::getAbschnittStrecke() const {

3
Aufgabenblock_2/Fahrzeug.h
View file

@ -20,14 +20,13 @@ public:
virtual void vAbfertigung();
virtual double dTanken(double dMenge = 0.0);
virtual double dGeschwindigkeit() const;
void vNeueStrecke(Weg *pWeg);
void vNeueStrecke(Weg *pWeg, double dStartZeit = 0.0);
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:

20
Aufgabenblock_2/FzgVerhalten.cpp
View file

@ -1,7 +1,6 @@
#include <stdlib.h>
#include <float.h>
#include "FzgVerhalten.h"
#include "Fahrzeug.h"
extern double dGlobaleZeit;
@ -13,16 +12,11 @@ FzgVerhalten::FzgVerhalten(Weg *pWeg) {
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;
double FzgVerhalten::getMaxgeschwindigkeit() {
switch (p_pWeg->getLimit()) {
case Innerorts: return 50;
case Landstrasse: return 100;
case Autobahn: return DBL_MAX; /* unbegrenzt */
default: return 0;
}
}

7
Aufgabenblock_2/FzgVerhalten.h
View file

@ -8,10 +8,11 @@ public:
FzgVerhalten(Weg *pWeg);
virtual ~FzgVerhalten();
double dStrecke(Fahrzeug *pFz, double dZeit);
virtual double dStrecke(Fahrzeug *pFz, double dDelta) = 0;
double getMaxgeschwindigkeit();
private:
Weg * p_pWeg;
protected:
Weg *p_pWeg;
};

4
Aufgabenblock_2/PKW.cpp
View file

@ -73,3 +73,7 @@ ostream& PKW::ostreamAusgabe(ostream &stream) const {
double PKW::dVerbrauch() const {
return p_dGesamtStrecke * p_dVerbrauch / 100;
}
double PKW::getTankinhalt() const {
return p_dTankinhalt;
}

1
Aufgabenblock_2/PKW.h
View file

@ -25,6 +25,7 @@ public:
ostream& ostreamAusgabe(ostream &stream) const;
double dVerbrauch() const;
double dTanken(double dMenge = 0.0);
double getTankinhalt() const;
private:
double p_dVerbrauch;

29
Aufgabenblock_2/Weg.cpp
View file

@ -3,13 +3,15 @@
#include "Weg.h"
#include "Fahrzeug.h"
#include "FahrAusnahme.h"
extern double dGlobaleZeit;
/* Standardkonstruktor */
Weg::Weg() : AktivesVO()
{ }
Weg::Weg(string sName, double dLaenge, Begrenzung eLimit) : AktivesVO(sName)
{
Weg::Weg(string sName, double dLaenge, Begrenzung eLimit) : AktivesVO(sName) {
p_dLaenge = dLaenge;
p_eLimit = eLimit;
}
@ -21,13 +23,21 @@ 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();
try {
(*iterator)->vAbfertigung();
} catch (FahrAusnahme &ausnahme) {
ausnahme.vBearbeiten();
}
}
p_dZeit = dGlobaleZeit;
}
void Weg::vAnnahme(Fahrzeug *pFz) {
pFz->vNeueStrecke(this);
void Weg::vAnnahme(Fahrzeug *pFz, double dStartZeit) {
pFz->vNeueStrecke(this, dStartZeit);
p_pFahrzeuge.push_back(pFz);
}
@ -35,9 +45,14 @@ double Weg::getLaenge() const {
return p_dLaenge;
}
Begrenzung Weg::getLimit() const {
return p_eLimit;
}
ostream& Weg::ostreamAusgabe(ostream &stream) const {
AktivesVO::ostreamAusgabe(stream) << resetiosflags(ios::left) << setiosflags(ios::right)
<< setw(24) << p_dLaenge << " ( ";
AktivesVO::ostreamAusgabe(stream) << setprecision(2)
<< 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) {

4
Aufgabenblock_2/Weg.h
View file

@ -23,9 +23,9 @@ public:
virtual ~Weg();
void vAbfertigung();
void vAnnahme(Fahrzeug *pFz);
void vAnnahme(Fahrzeug *pFz, double dStartZeit = 0);
double getLaenge() const;
Begrenzung getLimit() const;
ostream& ostreamAusgabe(ostream &stream) const;

52
Aufgabenblock_2/main.cpp
View file

@ -2,6 +2,7 @@
#include <vector>
#include <iostream>
#include "SimuClient.h"
#include "Fahrzeug.h"
#include "Fahrrad.h"
#include "PKW.h"
@ -36,7 +37,6 @@ void vAufgabe1() {
fz2->vAbfertigung();
fz3->vAbfertigung();
cout << endl << "globale Zeit: " << dGlobaleZeit;
cout << fz1 << endl << *fz2 << endl << *fz3 << endl;
}
@ -152,21 +152,57 @@ void vAufgabe3() {
}
void vAufgabe4() {
Weg weg("Allee", 15.0, Landstrasse);
PKW vw("Golf", 120, 6.7, 88);
Weg weg("Allee", 150.0, Landstrasse);
PKW vw("Golf", 110, 6.7, 88);
Fahrrad velo("Haibike", 22);
weg.vAnnahme(&vw);
weg.vAnnahme(&velo);
weg.vAnnahme(&velo, 1.1);
Fahrzeug::vAusgabeHeader();
while (1) {
dGlobaleZeit += 1.0/60;
while (dGlobaleZeit < 10) {
dGlobaleZeit += 0.1;
weg.vAbfertigung();
cout << vw << endl << velo << endl << weg << endl << "Globale Zeit: " << dGlobaleZeit << endl;
cout << vw << endl << velo << endl << weg << endl;
}
}
void vAufgabe5() {
Weg hin("Hinweg", 500.0, Landstrasse);
Weg rueck("Rueckweg", 500.0, Landstrasse);
PKW vw("Golf", 110, 6.7, 88);
Fahrrad velo("Haibike", 22);
bool bStarted = bInitialisiereGrafik(800, 600, true);
if (!bStarted) {
cerr << "Konnte Simulationsserver nicht starten!" << endl;
}
int iKoordinaten[] = {100, 100, 700, 500 };
bZeichneStrasse(hin.getName(), rueck.getName(), hin.getLaenge(), 2, iKoordinaten);
hin.vAnnahme(&vw);
rueck.vAnnahme(&velo);
Fahrzeug::vAusgabeHeader();
while (dGlobaleZeit < 10) {
dGlobaleZeit += 0.3;
hin.vAbfertigung();
rueck.vAbfertigung();
vSetzeZeit(dGlobaleZeit);
bZeichnePKW(vw.getName(), hin.getName(), vw.getAbschnittStrecke() / hin.getLaenge(), vw.dGeschwindigkeit(), vw.getTankinhalt());
bZeichneFahrrad(velo.getName(), rueck.getName(), velo.getAbschnittStrecke() / hin.getLaenge(), velo.dGeschwindigkeit());
cout << vw << endl << velo << endl << hin << endl << rueck << endl;
Sleep(500);
}
vBeendeGrafik();
}
int main() {
int iWahl;
@ -177,6 +213,7 @@ int main() {
cout << "2: vAufgabe2()" << endl;
cout << "3: vAufgabe3()" << endl;
cout << "4: vAufgabe4()" << endl;
cout << "5: vAufgabe5()" << endl;
cout << "Bitte wähen Sie eine Aufgabe: ";
cin >> iWahl;
cout << endl;
@ -187,6 +224,7 @@ int main() {
case 2: vAufgabe2(); break;
case 3: vAufgabe3(); break;
case 4: vAufgabe4(); break;
case 5: vAufgabe5(); break;
default:
cerr << "Ungültige Eingabe! Bitte versuchen Sie es erneut" << endl;
goto retry;