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??

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 :))

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

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)

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.

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

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

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

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

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

//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;