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
