Löschen in einer "for in" Schleife

[dominikkv]

Hallo,

ich stehe öfters mal vor dem Problem, dass ich eine Liste habe, und Einträge daraus löschen möchte:

Delphi-Quellcode:

var
  Eintrag: TMeinEintrag;
  Liste: TObjectList<TMeinEintrag>;

// ...

  for Eintrag in Liste do
     begin
      if Bedingung(Eintrag) then
         begin
          Liste.Remove(Eintrag);
         end;
     end;

Das ganze kann aber zu komischen Effekten führen - zum Beispiel wird bei mir jetzt gerade ein Eintrag übersprungen. Vielleicht kommt der Iterator nicht damit zurecht, wenn der aktuelle Eintrag aus der Liste gelöscht wird.

- Könnt ihr bestätigen, dass obiges Beispiel zu Fehlern führen kann?
- Wie löscht ihr bestimmte Einträge aus einer Liste? Eine "for I := Count - 1 downto 0"-Schleife möchte ich vermeiden.

Grüße
Dominik

[himitsu]

Das problem ist, daß der Standard-Enumerator nur den Index und das Ende kennt.
Er zählt einfach nur blind hoch und weiß nicht, daß du etwas löschst.

siehe TObjectList.GetEnumerator (das ist der Enumerator, welchen For-In nimmt, wenn du selbst Keinen explizit übergibst)


Die einzigen Lösungen sind da:
- kein For-In, sondern eine While- oder eine For-Downto-Schleife nutzen
- einen eigenen Enumerator nutzen
- - entweder muß der auch rückwärts laufen
- - oder er listet erst alles auf, merkt sich das und geht dann seine Liste durch
- wenn deine TList eine ToArray-Funktion hast, dann läßt du die Liste in ein Array umwandeln und läufst dann mit dem Standard-Enumerator der Arrays über die Kopie, wobei das Array von deinem Löschen auch nichts weiß und demanch alles von seiner Kopier dir presentiert.

[add]
die generiesche TObjectList<T> geht auf TList<T> und die hat ein ToArray
for Eintrag in Liste.ToArray do

Du kannst Emba auch fragen, ob die das Löschen in dem Standardenumerator berücksichtigen.
(dürfte mit zwei/drei Zeilen Quellcode möglich sein)

[jaenicke]

Die einfachste Lösung ist die zuletzt genannte:

Delphi-Quellcode:

  for Eintrag in Liste.ToArray do
     begin
      if Bedingung(Eintrag) then
         begin
          Liste.Remove(Eintrag);
         end;
     end;

Zitat von dominikkv:

- Wie löscht ihr bestimmte Einträge aus einer Liste? Eine "for I := Count - 1 downto 0"-Schleife möchte ich vermeiden.

Was spricht denn dagegen? Das wäre ja die schnellste Variante was den erzeugten Code angeht.

[Furtbichler]

Zitat von himitsu:

Das problem ist, daß der Standard-Enumerator nur den Index und das Ende kennt.

Den Index? Ich dachte immer, ein Eumerator kennt gerade *keinen* Index, sondern nur ein 'Start','Next' und 'Bin ich am Ende?'. Aber, klar: Der spezielle Listen-Enumerator arbeitet natürlich mit einem Index. Aber allgemein gesehen darf ein Enumerator keinen Index kennen. Ein gutes Beispiel ist ein Dataset oder ein Dateiverzeichnis: Dort gibt es wirklich nur die drei o.g. Befehle zum Navigieren.

Da eine For-In-Enumeration in der Umsetzung allgemeingültig sein muss, würde ich mich nie darauf verlassen, wie ein Iterator umgesetzt ist. D.h.: Löschen in Iterator: Nee.

Und deshalb sollte die Remove-Implementierung in der Liste sofort (fail-fast) eine Exception werfen, wenn ein Enumerator aktiv ist. So wie ich das hier lese, scheint das bei Delphi (mal wieder) nur halbherzig, d.h. gar nicht umgesetzt worden zu sein. Oder irre ich mich?

[Perlsau]

Zitat von Furtbichler:

Ein gutes Beispiel ist ein Dataset oder ein Dateiverzeichnis: Dort gibt es wirklich nur die drei o.g. Befehle zum Navigieren.

Theoretisch könnte man in einem Dataset auch mit RecNo navigieren:

Delphi-Quellcode:

Dataset.Last;
for i := 1 to Dataset.RecordCount do
begin
  DataSet.RecNo := i;
  ...
end;

Ist aber kein guter Programmierstil und birgt etliche Fallen. Deshalb: In DataSets immer nur mit Next, Prior, First und Last navigieren und beim Durchiterieren auf DataSet.Eof prüfen.

[dominikkv]

Hey danke für eure Antworten

Das mit dem .ToArray gefällt mir gut (und es klappt sogar ). Das erstellt zwar eine Kopie der Liste, aber das ist in diesem Fall vertretbar.

Zitat von jaenicke:

Zitat von dominikkv:

- Wie löscht ihr bestimmte Einträge aus einer Liste? Eine "for I := Count - 1 downto 0"-Schleife möchte ich vermeiden.

Was spricht denn dagegen? Das wäre ja die schnellste Variante was den erzeugten Code angeht.

Ja das ist in der Ausführung die schnellste Variante, allerdings ist Schnelligkeit nicht immer ausschlaggebend. In meinem Fall habe ich so um die 100 Einträge in der Liste, da lege ich mehr Wert auf Lesbarkeit des Codes, außerdem spare ich somit eine Variable

[Mikkey]

Wenn Du unbedingt das for .. in - Konstrukt verwenden willst, legst Du halt eine Löschliste an, in die Du alle zu löschenden Kandidaten übernimmst und nach vollständigem Duchlauf diese Kandidaten gezielt löschst.

In C# führt Dein Vorgehen regelmäßig zu einer Exception. Dort ist der Umweg über den Index i.A. nicht möglich, deshalb ist der obige ein häufig beschrittener Weg.

[Furtbichler]

Zitat von Mikkey:

... Dort ist der Umweg über den Index i.A. nicht möglich, deshalb ist der obige ein häufig beschrittener Weg.

Na ja, wenn du noch unbedingt mit .NET 2 hantieren musst, ja. Aber mit .NET 3.5 oder höher geht das aber noch einfacher

Code:

foreach (var item in myEnumerable.Where(ItemIsNotValidAnymore))
{
  myEnumerable.Remove(item);
}
...
bool ItemIsNotValidAnymore(MyEnumerableElement item)
{
 ...
}

Da braucht man noch nicht einmal mehr Kommentare.

[jaenicke]

Zitat von dominikkv:

außerdem spare ich somit eine Variable

Die Variable ist ja trotzdem da, nur halt in der zusätzlichen Enumerationsklasse.

[Furtbichler]

Zitat von dominikkv:

Ja das ist in der Ausführung die schnellste Variante, allerdings ist Schnelligkeit nicht immer ausschlaggebend. In meinem Fall habe ich so um die 100 Einträge in der Liste, da lege ich mehr Wert auf Lesbarkeit des Codes, außerdem spare ich somit eine Variable

Ich frage mich wirklich, was daran schlecht lesbar ist:

Delphi-Quellcode:

for i:=Liste.Count-1 downto 0 do 
  if Bedingung(Eintrag[i]) Then 
    Liste.Delete(i);

Oder findest Du die for-Schleife etwa 'old-school'? Den Umweg über ein Array zu gehen ist ja auch nicht gerade direkt, kurz und knapp, oder? Wenn Du das lesbar machen willst, dann benutze Refactoring;

Delphi-Quellcode:

...
LoescheBestimmteElementeAusDer(Liste);
...

Beim Lesen des Codes kann man ja wohl nicht anders, als zu lesen, was dort passiert. Da muss man noch nicht einmal großartig in die Routine reinspringen, weil das ja im Kontext der o.g. Routine sekundär sein dürfte.

Delphi-Quellcode:

Procedure LoescheBestimmteElementeAusDer(Liste : TListe);
var
  i : Integer;
Begin
  for i:=Liste.Count-1 downto 0 do 
    if Bedingung(Eintrag[i]) Then 
      Liste.Delete(i);
End;