class Liste
{
private:
  Liste* next;
public:
  Liste(Liste* Next = 0) : next(Next) {}
  ~Liste() {delete next;}
  Liste* Next() {return next;}
  Liste operator<<(Liste* secList) {
    //Die übergebene Liste an das letzte Element anhängen
    Liste* tempList = 0;
    for(tempList = this; tempList->Next() != 0; tempList = tempList->Next());
    tempList->next = secList;
    return *this;
  }
};

void main()
{
  Liste* myList = new Liste();
  *myList << new Liste() << new Liste() << new Liste();
}

Wenn man den Code ausführt erhält man eine Exception. Ich habe das ganze mal debuggt und herausgefunden, dass nachdem myList durch die mit

new Liste()

erzeugten Listen erweitert wurde, für alle Listenelemente, die eben an myList angehängt wurden der Destruktor aufgerufen wird.

Da das erste Element bereits alle nachfolgenen im Desktruktor löscht, wird eine Exception geworden, sobald das nächste Element mit delete gelöscht werden soll.
Soweit ist alles klar...

Aber warum macht C++ sowas? Wieso wird auf die im Heap allokierten Listen ein delete aufgerufen?

Wenn ich den operator<< so modifiziere, dass er eine Referenz zurückgibt, funktioniert alles wunderbar

Liste& operator<<(Liste* secList) {
...

Aber warum?

Thx

Wenn ich den operator<< so modifiziere, dass er eine Referenz zurückgibt, funktioniert alles wunderbar

Und was ist der Unterschied? Wenn du per value zurückgibst, wird eine Kopie von *this erstellt. Was passiert mit dieser Kopie im weiteren Verlauf?

Der Code sieht (auf das Wesentliche reduziert) so aus:

Die eigentliche Klasse besteht auch aus ein bisschen mehr, nur habe ich sie halt auf den funktionalen Kern reduziert, damit nicht diejenigen, die mir helfen könnten durch zig Zeilen code abgeschreckt werden