Memoryleak durch Erstellen v. Objekt in Function()?

[BMI]

Hi,

eigentlich dachte, ich das geht ganz einfach.
Naja, mittlerweile bin ich mir da nicht mehr sicher, ob das nicht ein unentdecktes Speicherproblem gibt.

Delphi-Quellcode:

function bildbearbeiten(EingangsImage: Timage): Tbitmap;
var a, b: Integer;
  imo: Tbitmap;
  pico: TPicture;
begin
  imo := Tbitmap.create;
  pico := TPicture.create;
  pico := EingangsImage.Picture; // jaa, intelligente Bezeichner ...
imo := pico.picture.bitmap
       {...} // Bearbeiten des Bildes
  result := imo; // übergabe als Referenz

// ACHTUNG, folgender FEHLER:
   pico.free; //<< kille ich die, 
   imo.free; // habe ich eine Exception
end; // Bild bearbeiten

Hier knallt's, weil die Referenz fehlt. Aber ich dachte die würde solange bestehen bleiben, bis an result übergeben und die Function verlassen - und schließlich beim Caller weitergearbeitet würde.

aufrufen tu ich hier mit

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
begin
image2.Picture.Bitmap := bildbearbeiten(image1);
//    pico.free;  << würde ich die hier oder im OnClose() <<<-#############################
//    imo.free;    löschen, wüßte Delphi nicht wo, oder was  <<<-#############################
end;

diese beiden ^^

Wo/ darf ich die pico.free; imo.free; hinschreiben?
Wo gehören die hin?

Erzeuge ich nicht ein Bitmap, ohne das wieder zu zerstören/freizugeben und verbleibt das dann nicht im RAM - kommen noch mehrere dazu?

Eine Übergabe an form1.image2.picture.bitmap := imo; möchte ich nicht machen, da man ja bei Functionen nie weiß, ob man die mal auch in anderen Units einsetzen möchte. (mir geht es um die Generalisierbarkeit)

Danke.

[Namenloser]

Ja, das gibt ein Memory-Leak, weil der Setter von TPicture.Bitmap nicht die Referenz übernimmt, sondern eine Kopie erstellt.

Die Implementierung sieht ungefähr so aus:

Delphi-Quellcode:

type
  TPicture = class
  private
    FBitmap: TBitmap;
    procedure SetBitmap(const ABitmap: TBitmap);
    // ...
  public
    property Bitmap: TBitmap read FBitmap write SetBitmap;
    // ...
  end;

procedure TPicture.SetBitmap(const ABitmap: TBitmap);
begin
  FBitmap.Assign(ABitmap); // <====
end;

Das heißt, wenn „ABitmap“ der Rückgabewert einer Funktion ist, dann wird der Rückgabewert nie freigegeben.

Du musst eine zusätzliche Variable benutzen:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  Tmp: TBitmap;
begin
  Tmp := bildbearbeiten(image1);
  image2.Picture.Bitmap := Tmp;
  Tmp.Free;
end;

[himitsu]

Objekte haben keine Referenzzählung.
(Ausnahme im ARC, dann sind die wie Interfaces)


imo.Free; darfst du sowieso niemals machen, denn du hattest auch niemals diese Instanz erstellt.
> imo := pico.picture.bitmap;

Delphi-Quellcode:

pico := TPicture.Create;
pico := EingangsImage.Picture;

Speicherleck, weil du was erstellt hast und danach aber in der selben Variale was anderes speichst.

Da pico nun ebenfalls nichts von dir ist, darfst du hier auch wieder nichts freigeben. (pico.free )

Außerdem dürftest du imo sowieso "hier" nicht freigeben, da das schließlich als Result zurückgegeben wird, wo es dann knallt, wenn jemand auf dieses Result zugreifen will.
objekte als Result sind immer grenzwertig, denn wer muß, darf, soll oder darf nicht das Objekt freigeben, welches diese Funktion zurückgibt?

Zitat:

image2.Picture.Bitmap

Hier wird zwar etwas zugewiesen, aber der Setter von .Bitmap nimmt diese Instanz nicht an.
Er macht sich eine eigene komplette Kopie dieses Bittmaps. (TBitmap.Create und kopiert den Inhalt dort rein)
Daher müsste hier anschließend auch Tmp.Free; . Aber nur, wenn bildbearbeiten eine "neue" Instanz zurück gibt, die man freigeben soll.

[sko1]

Warum erstellst Du die Bitmap nicht im Hauptprogramm und übergibst sie als var an die Funktion anstatt sie in der Funktion zu erstellen?
Dann weißt Du auch im Hauptprogramm wie und wann sie wieder zerstört werden kann.

Ciao
Stefan

[DeddyH]

Sehe ich ähnlich, aber bitte nicht als Var-Parameter (schließlich willst Du ja die Instanz nicht überschreiben), sondern einfach By Value oder als Konstante.

[haentschman]

Moin...

Ergänzung den Vorrednern...
Objekte erzeugen als Rückgabe ist möglich... aber: Dann sollte auch der Name suggerieren, das die Funktion eine neue Instanz erzeugt. (CreateBlubbBla)