typedef list<Partikel> Partikellist;
//..
Partikellist pl();
//...
pl.push_back(new Partikel(mx,my,0,-3));

fehler des Compilers

newmain.cc:107: Fehler: Abfrage des Elementes »push_back« in »pl«, das vom Nicht-Klassentyp »Partikellist ()()« ist

und wenn ich die elemente aus der liste wieder lösche, wird der Speicher dann wieder freigegeben?
oder hab ich das völlig falsch angefangen?

PS: Und Elemente, die du in die Liste einfügen willst, mußt du nicht per new anlegen (Randfrage: Bist du von Java auf C++ umgestiegen?)

Krux schrieb:

und wenn ich die elemente aus der liste wieder lösche, wird der Speicher dann wieder freigegeben?
oder hab ich das völlig falsch angefangen?

Was die Liste angefordert hat, gibt sie auch selber wieder frei - du mußt nur den Speicher zurückgeben, den du selber geholt hat (Merkregel: Zu jedem 'new' gehört ein 'delete').

Java hab ich dann allerdings an der Uni viel intensiver gelernt, wo ich viel schneller mit den Containern in berührung kahm.

und das zu jedem new ein delete kommt hab ich mir auch gedacht, deshalb kam mit das ja auch so komisch vor, aber wie mache ich das dann ohne new?

danke

new ist in dem Fall nicht nur unpassend, sondern komplett falsch - das liefert einen "Partikel*****", mit dem dein Container nichts anfangen kann.

(new bräuchtest du nur, wenn du eine list<Partikel*> verwenden würdest - und dann müsstest du dich auch selber darum kümmern, die Listen-Elemente zu delete'n)

In Java übergibt man ja die Pointer (auch wenn es offiziel ja keine gibt) an die Container, allerdings kümmert sich dann der Müllsammler (GC) um das freigeben des speicherbereiches. Ich hab mir gedacht, dass das in C++ ja auch hätte so umgesetzt worden sein können, das man die pointer übergibt, aber dann von der klasse deletet werden (wäre ja möglich).

ok wäre schön zu wissen, was ich denn dann überhaupt übergebe.
Ist das ein funktionspointer inklusive argumente (Funktionspointer stehen in meinem buch irgendwie nicht drin)

Nein, das ist ein temporär erzeugtes Objekt. Das ganze ist etwa äquivalent zu Partikel tmp(mx,xy,0,-3);pl.push_back(tmp); nur mit dem Unterschied, daß das Objekt keinen Namen bekommt (das ist aus deiner Sicht egal, erleichtert aber dem Compiler mögliche Optimierungen).

A a; // erzeugt ein objekt auf dem stack
A *a = new A; // erzeugt ein objekt auf dem heap

objekte auf dem heap werden automatisch freigegeben, wenn ihr gültigkeitsbereich verlassen wird. objekte auf dem heap erst dann, wenn sie explizit mittels delete freigegeben wurden.

d.h. wenn du in eine list stack objekte legst (list<Partikel>) dann werden diese auch automatisch wieder entfernt, wenn die list nicht mehr benötigt wird oder wenn du diese aus der liste entfernst. ausserdem werden die objekte tatsächlich in die interne datenstruktur der list kopiert.

ein list<Partikel*> würde eine list erstellen, die pointer auf partikelelemente aufnimmt. diese werden nicht automatisch wieder entfernt, auch wenn die list gelöscht wird. die pointer selbst werden zwar verschwinden, nicht aber das objekt im heap, auf die dieser pointer gezeigt hat.

list<A> l;
{
 A a;
 l.push_back(a); // a wird in die list kopiert
}
// a ist hier nicht mehr sichtbar, der gültigkeitsbereich wurde verlassen
// a ist somit "zerstört", allerdings existiert die kopie in der list noch

list<A*> l;
{
 A *a = new A;
 l.push_back(a);
}
// der pointer *a ist nicht mehr sichtbar, das objekt auf dem heap existiert
// allerdings noch und ein gültiger pointer befindet sich in der list

// und jetzt das c++ "problem"
list<A*> l;
{
 A a; // objekt auf dem stack
 l.push_back(&a); // mit &a wird die adresse ("pointer") des objekts in die list gelegt
}
// hier ist a nicht mehr sichtbar UND zerstört. der pointer in der liste zeigt
// auf bereits wieder freigegebenen speicher und ist somit ungültig.
// bei zugriff auf den pointer fliegt dir das programm um die ohren

Krux schrieb:

ok wäre schön zu wissen, was ich denn dann überhaupt übergebe.
Ist das ein funktionspointer inklusive argumente (Funktionspointer stehen in meinem buch irgendwie nicht drin)

Nein, das ist ein temporär erzeugtes Objekt. Das ganze ist etwa äquivalent zu Partikel tmp(mx,xy,0,-3);pl.push_back(tmp); nur mit dem Unterschied, daß das Objekt keinen Namen bekommt (das ist aus deiner Sicht egal, erleichtert aber dem Compiler mögliche Optimierungen).

Partikellist pl;
{
    Partikel tmp;
    pl.push_back(tmp);
}

pl.//mache irgendwas mit dem letzten objekt von pl

müsste dann ja auch funktionieren
erzeut der Container dann intern eine Kopie?

Edit:
ok jetzt ist alles klar
pl.push_back(Partikel(1,2,3,4))
erstellt also ein Partikel kopiert ihn und zerstört den zuerst erstellten dann wieder.

erzeut der Container dann intern eine Kopie?

jup

ich hab meine Liste an Partikeln, und die wird immer durchiteriert. Jedes Partikel hat eine gewisse lebensdauer, und wenn die Abgelaufen ist, das muss der Partikel weg. genau da ist mein Problm:

Partikellist::iterator pos;

for (pos = pl.begin(); pos != pl.end(); pos++ ){
    if(pos->update(dt))
        pos->draw(kreis);
    else{
        cout << "Jetzt wird gelöscht" << endl;
        pl.erase(pos);
    }
}

jetzt kommt direkt nach der Ausgabe "jetzt wird gelöscht" ein segmentation fault, und das Programm schmiert ab. Wie lösche ich richtig aus einer Liste?

pos = li.erase(pos);

dein code könnte übrigens noch aussagekräftiger sein, wenn du remove_if verwenden würdest:

struct NotUpdatable
{
  bool operator () (Particle &p) const
  {
    if (p.update())
    {
      p.draw();
      return false
    }
    return true;
  }
};

//...
li.remove_if (NotUpdatable());

pos = li.erase(pos);

benutze, überspringe ich dann nicht ein Objekt?

und was ist wenn ich continue einbaue, dann müsster der doch nicht pos++ durchführen oder?

Edit, ich hab mir grad mal continue genauer angeschaut (habs noch nie sinnvoll vverwenden können), und es geht nicht.

gewisse vorteile? welche denn?

ein temporäres objekt weniger, das erzeugt wird. kann geschwindigkeitsvorteile bringen (wenn exzessiv genutzt), schadet auf jedenfall nicht.

und was ist wenn ich continue einbaue, dann müsster der doch nicht pos++ durchführen oder?

Edit, ich hab mir grad mal continue genauer angeschaut (habs noch nie sinnvoll vverwenden können), und es geht nicht.

continue weist ja nur den nächsten schleifendurchlauf an. aber warum jetzt nicht einfach

for (list<Particle>::iterator pos = foo.begin(); pos != foo.end(); )
   {
      if (pos->update())
      {
         pos->print();
         ++pos;
      }
      else
      {
         pos=foo.erase(pos);
      }

oder
pos=--foo.erase(pos);
oder remove_if (ich lege es dir wirklich ans herz)

pos=--foo.erase(pos);

bei einer einfah verketteten liste? Ich denke nicht.

queer_boy schrieb:

oder remove_if (ich lege es dir wirklich ans herz)

ja vieleicht, wenn ich es verstehen würde.

queer_boy schrieb:

pos=--foo.erase(pos);

bei einer einfah verketteten liste? Ich denke nicht.

einfach verkettet? woher hast du das? immerhin verwendet list bidirektionale iteratoren..