Verwalten von Objekten in einer Container-Klasse

[sh17]

Zitat:

Zitat von IngoD7

So, wie TAdressBook da jetzt steht (also nur mit der Eigenschaft Contacts), hat es augenscheinlich keinen besonderen Nutzen. Da könnte man auch gleich eine TContactList instanziieren und verwenden.

Das muss ich jetzt aber mal eine Lanze für Luckie brechen: Dieser Thread stellt ein Tutorial dar, wie man das betreffende Problem ideal umsetzt und keine Codebibliothek für eine Adressverwaltung. Die Klasse hätte ja auch TDideldum heissen können. Wer erinnert sich nicht an solch sinnvolle Aufgabenstellungen an der Uni: Erstellen Sie eine JAVA-Anwendung, die ein Flugbuchungssystem abbildet...

Zitat:

Zitat von Luckie

Und genau deshalb wollte ich sie in dem Tutorial nicht verwenden.

Warum nicht? Man muss es sich doch nicht unnötig schwer machen. Sonst können wir ja IHMO gleich Assembler schreiben.

[Elvis]

Zitat:

Zitat von sh17

Warum nicht? Man muss es sich doch nicht unnötig schwer machen. Sonst können wir ja IHMO gleich Assembler schreiben.

Naja, für ein Tutorial finde ich es auch sinnvoll nicht TObjectList zu nehmen.
Wobei man hier weiter gehen könnte und eine eigene Liste implementieren kann, die man dann anstatt TList verwendet.

[sh17]

:duck: ok, ich halt mich raus

[Elvis]

Zitat:

Zitat von sh17

:duck: ok, ich halt mich raus

Pazifisten, pffft! :P

[sh17]

Zitat:

Zitat von Elvis

Pazifisten, pffft! :P

:shock: :twisted: Ich schreib wieder was, wenn's spannend wird.

[IngoD7]

Zitat:

Zitat von sh17

Zitat:

Zitat von IngoD7

So, wie TAdressBook da jetzt steht (also nur mit der Eigenschaft Contacts), hat es augenscheinlich keinen besonderen Nutzen. Da könnte man auch gleich eine TContactList instanziieren und verwenden.

Das muss ich jetzt aber mal eine Lanze für Luckie brechen:

Das brauchst du nicht. Es hat niemand eine Lanze vor Luckie in den Boden gerammt.

Letztlich sieht er es ja genauso, wie seine Antwort an Thorben_K ein Posting später zeigt.
Sowohl seinen als auch meinen Ausführungen ist diesbezüglich nichts hinzuzufügen.

Zitat:

Zitat von sh17

Wer erinnert sich nicht an solch sinnvolle Aufgabenstellungen an der Uni: Erstellen Sie eine JAVA-Anwendung, die ein Flugbuchungssystem abbildet...

Ich. :)

[Jens Schumann]

Zitat:

Zitat von Elvis

Eine streng typisierte Liste durch Erben von TList ist ein Ding der Unmöglichkeit.

Es könnte sein, das ich schon etwas eingerostet bin. Aber das sollte ein streng typisierter Nachfahre von
TList sein. Sieht eigentlich ganz einfach aus.

Delphi-Quellcode:

unit Unit2;

interface

uses classes;

Type

  TMyListItem = class(TObject)
  private
    FName: String;
    procedure SetName(const Value: String);
  public
    property Name : String read FName write SetName;
  end;

  TMyListItems = class(TList)
  protected
    function Get(Index: Integer): TMyListItem;
    procedure Put(Index: Integer; const Value: TMyListItem);
  public
    function Add : TMyListItem;
    procedure Clear; override;
    function Extract(Item: TMyListItem): TMyListItem;
    function First: TMyListItem;
    function IndexOf(Item: TMyListItem): Integer;
    procedure Insert(Index: Integer; Item: TMyListItem);
    function Last: TMyListItem;
    property Items[Index: Integer]: TMyListItem read Get write Put; default;
  end;

  implementation

{ TMyListItem }

procedure TMyListItem.SetName(const Value: String);
begin
  FName:=Value;
end;

{ TMyListItems }

function TMyListItems.Add: TMyListItem;
begin
  Result:=TMyListItem.Create;
  inherited Add(Result);
end;

procedure TMyListItems.Clear;
var
  iCnt : Integer;
begin
  For iCnt := 0 to Count - 1 do
    TObject(Items[iCnt]).Free;
  inherited Clear;
end;

function TMyListItems.Extract(Item: TMyListItem): TMyListItem;
begin
  Result:=TMyListItem(inherited Extract(Item));
end;

function TMyListItems.First: TMyListItem;
begin
  Result:=TMyListItem(inherited First);
end;

function TMyListItems.Get(Index: Integer): TMyListItem;
begin
  Result:=TMyListItem(inherited Get(Index));
end;

function TMyListItems.IndexOf(Item: TMyListItem): Integer;
begin
  Result:=inherited IndexOf(Item);
end;

procedure TMyListItems.Insert(Index: Integer; Item: TMyListItem);
begin
  inherited Insert(Index,Item);
end;

function TMyListItems.Last: TMyListItem;
begin
  Result:=TMyListItem(inherited Last);
end;

procedure TMyListItems.Put(Index: Integer; const Value: TMyListItem);
begin
  inherited Put(Index,Value);
end;

end.

[Elvis]

Zitat:

Zitat von Jens Schumann

Zitat:

Zitat von Elvis

Eine streng typisierte Liste durch Erben von TList ist ein Ding der Unmöglichkeit.

Es könnte sein, das ich schon etwas eingerostet bin. Aber das sollte ein streng typisierter Nachfahre von
TList sein. Sieht eigentlich ganz einfach aus.

Keine Sorge, gegen Rost gibt es Mittelchen in jedem Baumarkt. :mrgreen:
Wäre deine Liste wirklich streng typisiert könnte ich das nicht machen:

Delphi-Quellcode:

var
  list      : TMyListItems;
  item      : TMyListItem;
  evilValue : PInteger;
begin
  ...
  new(evilValue);
  list.Add(evilValue);

  item := list[0];

  WriteLn(item.Name); //Hmpf? Was steht denn da drin?

[Luckie]

Ich habe jetzt mal die Vorschläge eingearbeitet. Demo und PDF wurden auch aktualisiert.

[OldGrumpy]

Zitat:

Zitat von Luckie

Erst wird das Objekt in der Liste freigegeben und dann aus der selbigen gelöscht. Ebenso verfährt man beim Freigeben der Container-Klasse:

Delphi-Quellcode:

destructor TContactList.Destroy;
var
  i                 : Integer;
begin
  if FInnerList.Count > 0 then
  begin
    for i := FInnerList.Count - 1 downto 0 do
    begin
      TObject(FInnerList.Items[i]).Free;
    end;
  end;
  FInnerList.Free;
  inherited;
end;

Erst geht man die Liste durch und gibt alle in ihr enthaltenen Objekte frei. Dann gibt man die Liste selber frei. Wichtig ist, dass die Schleife rückwärts laufen muss, da die Eingangsbedingung einer for-Schleife nur beim Eintritt in die Schleife geprüft wird, aber in der Schleife entfernen wir ja Elemente, so dass wir, wenn die Schleife vorwärts liefe, über die Anzahl der Elemente hinauslaufen würden.

Ähm... also irgendwie passen diese Zeilen nicht zusammen... Du führst doch nur ein Free() aus und kein Delete() auf die einzelnen Objekte - die Schleife könnte also genauso gut vorwärts laufen. Isses schon zu spät oder hab ich gut aufgepasst? :mrgreen: