void flugzeug::FLzufall(int offenzeit, int offen){

flugzeug f; // klasse Flugzeug, kann ich dass überhaupt so machen, oder muss das schon die do schleife?
do{

Zufällige Erzeugung von Sprit und Ankunftszeit.
ID is aufsteigend.

f.setID(i);
f.setSprit(fuel);
f.setAnzeit(time_new);

i++;
//Jetzt soll dieses Flugzeug in eine Liste rein, wie mach ich das?
muss.
hier die Klasse:

class flugzeug{
private:
int id,sprit,anzeit;

public:
void FLzufall(int offenzeit, int offen);
void setID(int idc) { id = idc; }
void setSprit(int spirtc) { sprit = spirtc; }
void setAnzeit(int anzeitc) { anzeit = anzeitc; }
void getFlight();

};

Eine Klasse muss vor ihrer Benutzung bekannt und vollständig definiert sein.

class flugzeug{
private:
int id,sprit,anzeit;

public:
void FLzufall(int offenzeit, int offen);
void setID(int idc) { id = idc; }
void setSprit(int spirtc) { sprit = spirtc; }
void setAnzeit(int anzeitc) { anzeit = anzeitc; }
void getFlight();

};

Das in einen Header und dann in der zugehörigen .cpp noch die Funktionen FLzufall und getFlight definieren. ( ctor anbieten wäre auch eine gute Möglichkeit)

Und dann kannst du nachher die Klasse benutzen, wie du magst:

std::list <flugzeug> flugzeuge;

//100 flugzeuge erzeugen und in liste schieben
for (int i = 0; i < 100; ++i )
{
flugzeug f; //erzeugen
f.setID ( 333 ); //allenfals ein random generator
f.setSprit ( 200 ); //dito
//...
flugzeuge.push_back ( f ); //in liste einfügen
}

Wie Baue ich einen gescheiten Konstruktor dafür?

Hab das so gemacht. Heißt das jetzt, dass der in die liste, die klasse so reinschreibt?
Wie kannn ich die dann wieder ausgeben, wenn ich jetzt ein Flugzeug nach der ID abfragen will, wieviel sprit und welche anzeit es hat?

http://www.cplusplus.com/reference/stl/list/

Du kannst in einer Liste suchen.

http://www.cplusplus.com/reference/algorithm/

Und auch ein Konstruktor sollte kein Problem darstellen:

class flugzeug{
private:
int id_;
int sprit_
int anzeit_;

public:
flugzeug ( int id, int sprit, int anzeit )
: id_ ( id ),
sprit_ ( sprit ),
anzeit_ ( anzeit )
{}
//...
}

So kannst du die Anfangswerte gleich bei der Konstruktion eines Objektes übergeben und musst nicht noch nachher die setter aufrufen.

Ich habe jetzt so einen Konstruktor erstellt:

flugzeug::flugzeug(int idc, int spritc, int anzeitc)
{
id = idc;
sprit = spirtc;
anzeit = anzeitc;
}
~Flugzeug();

in der cpp dann:

flugzeug f(id, sprit, time_new);

id++;

data.push_back (f);

flugzeug::flugzeug(int idc, int spritc, int anzeitc)
{
id = idc;
sprit = spirtc;
anzeit = anzeitc;
}
~Flugzeug();

Mach das lieber so:

flugzeug::flugzeug(int idc, int spritc, int anzeitc)
: id ( idc ), //Initialisierungsliste
sprit ( spritc ),
anzeit ( anzeitc )
{}

Ansonsten werden die Werte initialisiert und danach noch zugewiesen. Macht da keinen grossen Unterschied, aber spätestens, wenn du const Werte hast, wirst du auf die Initialisierungsliste angewiesen sein.
Den dtor kannst du auch weglassen, oder leer lassen, da du nichts aufräumen musst.

void flugzeug::getFlight(int id) {

	list<flugzeug>::iterator it;

	it = id;

	cout<<...

die id ist quasi gleich der position in der liste.
Wie kann ich jetzt das Flugzeug mit seinen eigenschaften ausgeben lassen?

Du kannst den Iterator mittels std::advance um einen bestimmten Betrag verschieben, oder die, in solchen Fällen üblichere Variante nehmen und mittels std::find den Eintrag suchen.

Ich will ja das Flugzeug an der Position in der liste suchen.
Kann ich auch nach Kriterien wie sprit suchen? und Wie?

So wie ich es jetzt hab läuft es nicht.

void getFlight(int id) {

	list<flugzeug>::iterator it;

	it = find(data.begin(), data.end(), id );

	cout<< *it <<endl;

}

außerdem bekomm ich folgende fehlermeldung:
(benutze eclipse mit mingw)

Description Resource Path Location Type
")) << (&it)->std::_List_iterator<_Tp>::operator* [with _Tp = flugzeug]()' flug_erstellen.cpp Airport/src line 69 C/C++ Problem

danke!

Wenn du aber trotzdem eine liste hast, eignet sich zum suchen std::find_if :

class find_id
{
  int id_;

  public:
  find_id ( int id )
  : id_ ( id ) {}

  bool operator () ( const flugzeug & v ) { return v.get_id () == id_; }
};

void getFlight(int id) {
    list<flugzeug>::iterator it;
    it = find_if(data.begin(), data.end(), find_id ( id ));
    cout<< *it <<endl;
}

wieso erstell ich für die funktion find_if eine klasse? Kann ich zur ausgabe nicht schon mit meiner klasse flugzeug realisieren?

class flugzeug{
	private:
		int id,sprit,anzeit;

	public:
		int landezeit;
		bool umleiten,abgestuerzt;

		flugzeug::flugzeug(int idc, int spritc, int anzeitc)
		: id(idc), sprit(spritc),anzeit(anzeitc)				
		{}

};

und dieser operator (), muss der nicht ein namen haben? oder soll das der Operator für mein * vom cout<<*it sein?

bool operator () ( const flugzeug & v ) { return v.get_id () == id_; }

und diese v.get_id ist doch das, worin dann mein cout gemacht wird??
Aber ist eine bool Fkt. nicht eine Funktion mit nur true / false als rückgabe wert?
Oder ist

Der getter sollte nur genau das machen, wofür er gedacht ist und das ist alleine dir Rückgabe des Wertes und nicht noch automatisch etwas ausgeben.

Der Rückgabewert ist der Vergleich des Wertes im Objekt mit dem gesuchten Wert. Sobald der Wert gefunden wurde wird true zurückgegeben und du bekommst deinen iterator drauf.

@drakon: Du meinst wohl find_id, denn find_if ist die funktion, nicht der funktor.

Jop, habe mich verschrieben.

const flugzeug & v

Jetzt musst ich ja in meine klasse flugzeug noch die funktion get_id schreiben.

int get_id() { return id; }

aber da bringt er mir den fehler:

passing `const flugzeug' as `this' argument of `int flugzeug::get_id()' discards qualifiers

....
Jetzt musst ich ja in meine klasse flugzeug noch die funktion get_id schreiben.

int get_id() { return id; }

aber da bringt er mir den fehler:

passing `const flugzeug' as `this' argument of `int flugzeug::get_id()' discards qualifiers

Weil Du sie zwar geschrieben ... aber nicht richtig geschrieben hast:

int get_id() const { return id; }

Gruß,

Simon2.

P.S.: Es bietet sich IMMER an, bei der Funktionsdeklaration gleich einen kurzen Gedanken daran zu verschwenden, welche Objekte wirklich durch diese Funktion geändert werden sollen (möglichst minimal) ... und die Anderen mit const zu kennzeichnen.

Nochmal eine Frage, ich habe mir auch gleich einen Funktor für die Formatierte Zeitausgabe gebaut.
Der funktor befindet sich jetzt in der header datei, dort ist ja aber dieser iostream nicht eingebunden. Sprich ich kann nich einfach so cout in dem funktor ausführen.
Wie lös ich das am kleversten? kann man überhaupt #include im header ausführen? Oder muss ich es kompliziert zurückgeben?
mfg

class find_id{

	public:
		bool operator () (int id_, const flugzeug & v ) const {
			return v.get_id () == id_;

oder so:

class find_id{
	private:
	        int id_;

	public:
		find_id ( int idx )
		: id_ ( idx ) {}
		bool operator () ( const flugzeug & v ) const {
			return v.get_id () == id_;