problem, wie geht man hier vor? eine recht interessante aufgabe

theTOASTA

Hi Leute, ich habe hier ne lustige Aufgabe bekommen, weiss aber ni so genau wie ich da ran gehn soll bzw muss...

Ich soll eine FlughafenSimulation nach folgender Beschreibung realisieren:

zufällig sollen flugzeuge erscheinen die einen service (starten oder landen) in anspruch nehmen wollen. Luftkontrolle soll den Betrieb der Flugzeuge in der Luft übernehmen, sie leitet auf wlandung wartende flugzeuge über den flughafen um. bodenkontrolle kümmert sich um die flugzeuge die sich am boden befinden und leitet diese um. dann gibts noch flughafen, flughafen verwaltet die warteschlangen und kontrollen des verkehrs am boden und in der luft. flughafen unterliegt auch die rollbahn.
die flugzeiten und verzögerungen sollen durch eine globale zeit simuliert werden. das ganze ist als scheduling problem mit warteschlangen zu implementieren.

die flugzeuge sollen zufällig erscheinen und entweder in warteschlange für starten oder für landen gesetzt werden. die flugzeuge haben eine maximale restflugzeit, wenn diese abläuft (weil so lange in der schleife) dann stürzen sie ab. und sonst sind noch n paar ausgaben wie: flugzeug kommt an und will landen, bla bla bla

wie in gottes namen geh ich da vor??

rüdiger

Kommt darauf an wie du das entwerfen willst.

OOP wäre folgendes. Du machst aus jedem Subjekt in der Beschreibung eine Klasse mit entsprechenden Instanzen (eben n-Flugzeuge, m-Luftkontrollen, k-Flughäfen, k-Bodenkontrollen). Aus allen Prädikaten machst du Methoden der Klassen. Dann brauchst du eben noch einen Flugzeug-Generator und eine Hauptschleife, die alles verbindet.

Prozess basiert (ala Erlang) wäre dagegen wohl aus jedem interagierenden Subjekt ein Prozess zu machen und jedes Prädikat in eine Nachricht zu verwandeln

Ich hoffe ich hab dir einen sinnvollen Anstoß gegeben.

(btw. versuch bitte bessere Topics zu benutzen. Etwas ala "Software-Design einer Luftraum-Simulation" wäre zumindest ein bisschen hilfreicher :))

theTOASTA

eine super antwort...
warum ich ich den namen des themas so gewählt habe weiss ich auch nicht. wollte es interessanter machen

also das programm soll OOP sein als konsolenapplication.
hast mir schon sehr geholfen! mal sehn wie weit ich komme...

theTOASTA

wie mach ich das mit den warteschleifen?? bzw wie soll ich vorgehen, damit mehrere flugzeuge verarbeitet werden könnem?

rüdiger

Eine Wartschleife ist ja im Grunde eine std::deque<Flugzeug> warteschleife .

Du pushst eben am Anfang rein und popst Flugzeuge am Ende raus, wenn du Timeslots zum landen frei hast.

(wobei du je nach wenn du keine first-come-first-serve haben willst (zB weil du den Benzin-Stand berücksichtigen willst) eine std::priority_queue nehmen solltest)

Gregor

Vielleicht noch zwei passende Stichwörter, die mir hier relevant erscheinen:

1. Ereignisorientierte Simulation

2. Prozessorientierte Simulation

In dem Zusammenhang gibt es ganz allgemeine Herangehensweisen an solche Probleme. Und entsprechend gibt es auch allgemeine Frameworks, die einen dabei unterstützen. Unter Java kenne ich da zum Beispiel DesmoJ. Für C++ wird es ähnliche Frameworks geben. Müsstest mal selbst suchen. Vielleicht ist es sinnvoll, sich vom Design des Programms etwas daran zu orientieren, wie das in diesen Frameworks gemacht wird.

...ok: Andererseits ist das für so ne kleine Aufgabe sicherlich Overkill.

Werner Salomon

theTOASTA schrieb:

wie in gottes namen geh ich da vor??

Nun, zunächst überlegst Du was Input und Output von Deinem Programm ist.

Dann versuchst Du sogenannte Anwendungsfälle (Use Cases) zu beschreiben (in Worten). Jeder Use Case beginnt mit einem Ereignis (kann auch das Verstreichen einer Zeit sein - z.B. Timer) und endet mit einem Nutzen für den Anwender.

Z.B. Taschenrechner - Ereignis ist: Anwender tippt zwei Summanden mit '+' getrennt, als Ergebnis wird die Summe ausgegeben. Der Nutzen für den Anwender besteht darin, dass er die Summe ablesen kann.

Dann suchst Du alle Hauptwörter in Deiner Beschreibung heraus, denn das sind potentielle Kandidaten für Klassen. Aus Deinen Use Cases sollte klar werden wie sie interagieren.
Für jede Klasse kannst Du Beziehungen definieren (zu welcher anderen Klasse? welcher Art? welche Kardinalität (Anzahl)?) und eine Verantwortung, die die Klasse hat (siehe auch CRC). Letzteres ist nicht mit ihrer Aufgabe zu verwechseln.

Dann muss man sich noch für einen Rahmen entscheiden; das wurde schon erwähnt, es wird wahrscheinlich eine Hauptschleife, die mit jedem Durchlauf ein Zeitintervall simuliert.

Versuch' mal einen Use Case - oder zumindest einen Teil davon - zu beschreiben.

Gruß
Werner

Gast++

Interessante Aufgabe!

Es ist imo irgendwie verlockend die Flugzeuge jeils in einem eigenen Thread "fliegen" zu lassen; eine Schleife koennte den Benzinvorrat zyklisch dekrementieren und bei entsprechender Dringlichkeit Nachrichten("queue me", "prioritze me"...) an einen Hauptthread senden der die Warteschleife managed.

Grüsse

*this

theTOASTA

Danke für die vielen Tips!! Bin schon viel weiter gekommen, jetz hab ich allerdings ein Problem mit den queues... wie muss ich die implementieren? habe mit templates ni so die erfahrung...
gibts da irgendwo gute beispiele?

kann ich überhaupt ein Objekt (z.b.Flugzeug) is eine solche queue ablegen? ja oder?

CStoll

Die brauchst du nicht zu implementieren, die liefert die Standard-Bibliothek schon mit - die Klasse queue<> stellt eine einfache (FIFO-)Warteschlange dar, priority_queue<> eine Prioritäts-Warteschlange (immer der höchstwertige Eintrag kann als nächstes entnommen werden).

theTOASTA

kann ich bei der prio festlegen nach welchem parameter des objekts die auswahl erfolgt?

gibts irgendwo gute beispiele wo ich mir mal anschauen kann wie das genau auszusehen hat?

CStoll

Ja, der gibst du als Template-Parameter einen Funktor, der vergleichen soll, welches von zwei Objekten "größer" ist (die Defaultvorgabe ist "größer als").

theTOASTA

wie geht das genau?
sorry, dass ich mich etwas anstelle, aber der mensch wächst mit seinen herausforderungen trotzdem braucht man manchmal hilfe...

otze

du überlädst einfach den "operator<"

also so:

bool operator<(const Flugzeug& o1,const Flugzeug & o2)
{
    return o1.benzinstand<o2.benzinstand;//Beispiel
}

der queue selbst brauchst du dann nichts mehr übergeben.
Problematisch wird das nur dann, wenn du bei verschiedenen queues flugzeuge nach anderen Gesichtspunkten sortieren willst. zb Passagiere, dann brauchst du eine andere Funktion.

das geht dann so:

bool vergleichePassagierzahl(const Flugzeug& o1,const Flugzeug & o2)
{
    return o1.passagierzahl<o2.passagierzahl;
}

//und die queue sieht dann so aus:
std::priority_queue<Flugzeug,std::vector<Flugzeug>,vergleichePassagierzahl> queue;

aber aufpassen: die priority_queue testet nur ein einziges mal, an welcher stelle ein Objekt gehört, ändert sich nach dem einfügen was an der reihenfolge, ist das der queue absolut egal.

Was auch nicht geht, ist einfach die vergleichsfunktion zu wechseln. die funktion wählst du einmal, und das bleibt dann.

hier mal die referenz der queue(auf der seite findest du auch informationen zu allen anderern containern):
http://www.sgi.com/tech/stl/priority_queue.html

CStoll

Der zweite Code wird nicht so ganz funktionieren - priority_queue erwartet einen Typ (also Funktor):

//Variante 1:
std::priority_queue<Flugzeug,std::vector<Flugzeug>,(bool*)(const Flugzeug&,const Flugzeug&)> queue(vergleichePassagierzahl);

//Variante 2 (vermutlich eleganter):
struct vergleichePassagierzahl
{
  bool operator()(const Flugzeug& o1,const Flugzeug & o2)
  {
    return o1.passagierzahl<o2.passagierzahl;
  }
};

std::priority_queue<Flugzeug,std::vector<Flugzeug>,vergleichePassagierzahl> queue;

theTOASTA

ok, das sollte soweit funktionieren... wie bekomm ich eine referenz auf das mit der höchsten priorität versehene objekt?