ich baue gerade eine std::list mit verschiedenen Kindern auf. Folgendes:

class A { int zahl; };
class B : public A { int nochnezahl; };
class C : public A { int anderezahl; };

typedef std::list<A*> MyListe;

A* a = new A();
a->zahl=1;

B* b = new B();
b->zahl=2;
b->nochnezahl=3;

C* c = new C();
c->zahl=3;
c->anderezahl=4;

MyListe L;
L.push_back(a);
L.push_back(b);
L.push_back(c);

MyListe::iterator it;
for (it=L.begin(); it!=L.end(); L++)
{
  cout << *it->zahl; // Geht und findet die richtigen Zahlen.
}

for (it=L.begin()); it!=L.end(); L++)
{
  delete *it; // Speicher-Leaks bei B* und C*
}
L.clear();

Im groben mache ich genau das. Jetzt ist mir aufgefallen, dass ich Memory-Leaks bekomme. Und zwar bei, delete der Zeiger auf das B*- und C*-Element. Anscheinend kann man kein "delete A*" für ein Element von "B*" ausführen, weil dann nur die "A*"-Bereiche freigegeben werden. Der Rest bleibt wohl im Speicher liegen und ergibt das Leak.

Kann man das irgendwie trotzdem lösen?
Ich hab im Internet etwas gestöbert und etwas von auto_ptr gelesen, aber gleichzeitig viele Seiten gefunden, die davon abraten einen auto_prt in eine std::list zu legen. Außerdem finde ich gerade keinen Ansatz um den auto_prt irgendwie auf meine 3 Klassen passen zu schreiben.
auto_prt die Lösung oder ein falscher Ansatz?

Frage: Wie kann ich in einem Listendurchlauf meine Pointer per delete löschen, ohne das etwas im Speicher zurück bleibt.

Danke,
Stefan

PS: Ich brauche die Strukturen, weil in der Klasse A eine virtuelle Funktion (für die Ausgabe) liegt, die in B und C virtuell überschrieben werden.

da ich intern "nur" mit einfachen Variablen gearbeitet habe hatte ich gar keinen d'tor.

virtual ~A() {}

war die Lösung.

Immer im Hinterkopf behalten

(Bedenke: wenn du eh schon eine virtuelle Funktion hast, kannst du ruhig immer den Dtor auch virtuell setzen - denn es kostet quasi garnichts).