TIntList - Array freigeben?

[bigg]

moin

Ich beschäftige mich zur Zeit mit Klassen und wollte draufhin eine einfache Zahlenliste anfertigen,
vom Aufbau her ähnlich der TStringList.

Nun meine Frage:
In der Prozedur Delete erstelle ich ein zweites Array "a"
und fülle es. Anschließend weise ich meiner Basis-Liste (FIntList) den Zeiger von a zu.
Also zeigt FIntList nun auf die Daten von A, aber was passiert mit den Daten von FIntList?
Muss ich die nicht freigeben?

Mich wundert es nur, das der Taskmanger nicht ausschlägt

Delphi-Quellcode:

unit IntList;
interface

uses
Windows, SysUtils;

type
  TIntList = class(TObject)
  private
    FIntList: Array of Integer;

  public
    constructor Create;

    procedure Add(Int: Integer);
    procedure Clear;

    function  Count: Integer;
    function  Get(Int: Integer): Integer;

    procedure Delete(Int: Integer);
    procedure Free;
    procedure Insert(p, Int: Integer);
end;

implementation

////////////////////////////////////////////////////////////////////////////////
// Klasse erstellen
////////////////////////////////////////////////////////////////////////////////

constructor TIntList.Create;
begin
  inherited;
  Clear;
end;

////////////////////////////////////////////////////////////////////////////////
// Alle Einträge löschen
////////////////////////////////////////////////////////////////////////////////

procedure TIntList.Clear;
begin
FreeMemory(FIntList);
SetLength(FIntList, 0);
end;

////////////////////////////////////////////////////////////////////////////////
// Zahl hinzufügen
////////////////////////////////////////////////////////////////////////////////

procedure TIntList.Add(Int: Integer);
var i: Integer;
begin
i := High(FIntList) + 1;
SetLength(FIntList, i + 1);
FIntList[i] := Int;
end;

////////////////////////////////////////////////////////////////////////////////
// Gesamtanzahl ermitteln
////////////////////////////////////////////////////////////////////////////////

function TIntList.Count: Integer;
begin Result := High(FIntList) + 1;
end;

////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////

function TIntList.Get(Int: Integer): Integer;
begin Result := FIntList[Int];
end;

////////////////////////////////////////////////////////////////////////////////
// Zahl an einem bestimmten Index löschen
////////////////////////////////////////////////////////////////////////////////

procedure TIntList.Delete(Int: Integer);
var i, h, c: Integer;
var a: Array of Integer;
begin
  c := 0;
  if Int > -1 then
  begin
    h := High(FIntList);

    if h > -1 then
    begin
      SetLength(a, h);

      for i := 0 to h do
      begin if int <> i then
      begin
        a[c] := FIntList[i];
        inc(c);
      end;
      end;

      FIntList := Pointer(a);
    end;
  end;
end;

////////////////////////////////////////////////////////////////////////////////
// Zahl an einem bestimmten Index einfügen
////////////////////////////////////////////////////////////////////////////////

procedure TIntList.Insert(p, Int: Integer);
begin

//

end;

////////////////////////////////////////////////////////////////////////////////
// Liste freigeben
////////////////////////////////////////////////////////////////////////////////

procedure TIntList.Free;
begin
Clear;
FIntList := nil;
end;



end.

[Luckie]

Eigentlich schon. Du kopierts ja nur den Zeiger, der halte wird ja nicht freigegeben. Aber vorsicht, wenn du Zeiger a freigibst, wird auch der Zeiger von FIntList ungültig. Aber das soll bitte noch mal jemand verifizieren. Ich stehe mit Zeigern immer etwas auf Kriegsfuss.

[marabu]

Hallo bigg,

FreeMemory, New, Dispose sollen laut Borland nicht auf dynamische arrays angewendet werden. Für ein dynamisches array (da) reservierst du Speicher mit SetLength(da, 10) und gibst ihn mit da := nil wieder frei. Da der Compiler für dynamische arrays die gleiche Referenzzählung verwendet wie für lange strings, wird in deiner Methode Delete() beim Zuweisen eines neuen arrays an FIntList dessen Zähler verringert und der Speicher freigegeben.

Wenn du den Code produktiv einsetzen möchtest, dann solltest du erwägen, ob du TIntList nicht von TList ableitest. Wenn du dann einen Quicksort spendierst und die Integers geordnet speicherst, geht alles viel schneller und sicherer.

Grüße vom marabu

[bigg]

,

@marabu:
ja da hast du recht, mit nil wird Speicher freigegeben.
Ich werde die Liste mal noch vervollständigen.

Eine Liste mit Pointern wäre natürlich auch interessant.


bye