Listen zurückgeben - best practice

[Meflin]

Ich habe Funktionen, die prinzipiell generische Listen erstellen, mit denen weitergearbeitet können werden soll.

Intuitiv würde man schreiben:
function foo(): TList<MyClass> Daraus ergibt sich natürlich das altbekannte Problem: wer gibt diese Liste wann wieder frei? Ist dies nun vertretbar, das dem Benutzer der Library zu überlassen?

Oder sollte man doch besser nen Iterator/Enumerator (was ist eigentlich der Unterschied?) zurückgeben, aber wie würde das konkret funktionieren, im Hinblick auf die generische Liste?

Delphi-Quellcode:

function foo(): ?
var
  List: TList<MyClass>;
begin
  List := TList<MyClass>.Create;
  ...
  Result := ?
end;

Selbst wenn man den Fragezeichenteil korrekt ergänzen könnte hätte man aber doch immernoch das selbe "Speicherleck"?! Mir fehlt grade die zündende Idee...

[himitsu]

Delphi-Quellcode:

procedure foo(result: TList);
begin
  ...
end;


List := TList<MyClass>.Create;
foo(List);
List.Free;

[Neutral General]

Also ich habe es bisher über einen var/out Parameter gelöst.

Da kann der Benutzer der Funktion nicht aus Versehen den Rückgabewert ignorieren.
Also sowas wie:

Delphi-Quellcode:

function foo(): TList<MyClass>
begin
  Result := ...
end;


begin
  foo(); // BÖSE
end;

geht dann nicht.

Bei mir ginge es dann so:

Delphi-Quellcode:

function foo(var Result: TList<MyClass>): Irgendwas; // oder Procedure
begin
  Result.DoSomething;
  Result.Add(Irgendwas);
end;

var AList: TList<MyClass>;
begin
  AList := TList<MyClass>.Create(...);
  try
     foo(AList);
     // Do something with AList
  finally
    AList.Free;
  end;
end;

[Meflin]

out-Parameter möchte ich nach Möglichkeit vermeiden...

[s.h.a.r.k]

Delphi-Quellcode:

function CreateFoo(): TList<MyClass>;
begin
  ...
end;

List := CreateFoo();
List.Free;

Die Lösung von himitsu wird wohl die beste sein, da man den Code dann einfacher lesen kann. Um aber ab und zu ein wenig Code einzusparen, nutze ich aber gerne obige Konstruktion. Ich setze vor den Methodennamen noch ein "Create", sodass ich dann beim Aufruf sehe, dass etwas erzeugt wird. Ein wirklicher Vorteil ists nicht.

[p80286]

Darf ich mich hier einklinken?
was ist z.B. mit solchen Konstrukten:

Delphi-Quellcode:

function Testlesen(fn:string):tstringlist;
var
  tl : tstringlist;
begin
  tl:=tstringlist.create;
  tl.loadfromfile(fn);
  tl.sort;
  result:=tl;
end;

...
form1.memo1.text:=Testlesen('c:\meinedatenwoauchimmer').text;
....

Da sollte die Stringliste ja auch bis zum Programmende Speicher belegen.

Gruß
K-H

[DeddyH]

Jepp, das kann man mit FastMM schön überprüfen.

[Meflin]

Weils irgendwie grade passt

Was ist eigentlich damit:

Delphi-Quellcode:

foo = record
  bar: TList<wuppdi>;
end;

...

function k(): foo;
a := k();

Gibts ein Speicherleck oder wird die Liste mit aufgeräumt?


Garbage Collection FTW.

[Neutral General]

Das gibt ein Speicherleck, wenn du die Liste im Record erstellst, aber nicht freigibst.

Zitat:

Garbage Collection FTW.

Ich vertraue den Viechern nicht^^ Als ich mal was mit C# gemacht hab, hat mir das GAR NICHT gepasst, dass der GC meinen Müll erst keine-Ahnung-wann aufgesammelt hat Ich passe da lieber selbst auf

[s.h.a.r.k]

Außer man setz einen Destructor zusätzlich ein, man muss diesen dann aber halt auch aufrufen