Wer macht den Free?

[Mavarik]

Hallo!

Ich refrakturiere gerade alten Source-Code für einen Kollegen...

Die Frage ist: Wer gibt eine Instance wieder frei... (Gibt's sicher wieder ne tolle Regel)

Beispiel:

Delphi-Quellcode:

Procedure Foo; // Logisch...
var
  LListe : TStringList;
begin
  LListe := TStringList.Create;
  try
    // Whatever
  finally
    LListe.Free; 
  end;
end;

Procedure Bar(Const AListe : TStrings); 
begin
  // Whatever
  
  AListe.Free; // oder nicht?  (wenn kein Const dann klar!)
end;

Function Foo2(Const AParam1,AParam2 : String) : TStrings;
begin
  Result := TStringList.Create;
  Result.AddPair(AParam1,AParam2);
  // Whatever
  // Logischerweise kein Free
end;

Procedure Bar2;
begin
  Bar(Foo2('Value','42'));  
end;

Was ist wenn ich den Source von Bar nicht habe und in der Doc nix steht...

Angenommen Bar gibt die Instance nicht frei, dann ist es ein MemLeak!

Delphi-Quellcode:

Procedure Bar2;
var
  LStrings : TString;
begin
  LStrings := Foos2('Value','42');
  try
    Bar(LStrings);  // Dann hoffen wir mal Bar hat FreeAndNIL verwendet...
                    // Es sei den der Param ist ein Const dann geht FreeAndNIL nicht... 
  finally
    FreeAndNIL(LStrings);
  end;
end;

Besonders wenn man fremden Source liest, sieht man ggf. nicht ob man ein Object frei geben muss oder nicht.

Delphi-Quellcode:

Function Bar3(Const AListe : TStrings) : TStrings;
begin
// Den Source kenne ich nicht...  
end;

Function Bar4;
var
  LListe : TStrings;
begin
  LListe := Bar3(Foo2('Value','42'));
  // Ist LListe meine Instance von Foo2 oder eine neue?
  LListe := Foo2('Value','42');
  LListe := Bar3(LListe); // Hab ich jetzt ein MemLeak?
end;

Wie macht Ihr das?

Mavarik