Record Verwalten - Wie am besten ?

[turboPASCAL]

Hi,

ich mochte einen/mehrere Record(s) verwalten. Ich habe das jetzt mit einem dyn. Array gelöst,
was mir aber nicht so gefällt. Ich habe da an TList gedacht komme aber nicht so recht voran.

Ich möcht in der Liste auf den Record über einen Index, was ja nun eion Problem ist, aber auch
über einen Namen zugreifen können und da fällt mir nix ein...

Pseudocode

Code:

type
  myRecord = record
    Handle: int
    Titel: string
  end;

type
  myRecordList = List of myRecord


begin
  myRecordList.add(Handle1, 'Abc');
  myRecordList.add(Handle2, 'Def');
  myRecordList.add(Handle3, 'Ghi');

  
  // holen per List-Index //
  anyHandle :=  myRecordList[Idx].Handle
  anyTitel  :=  myRecordList[Idx].Titel

  // holen per List-Index //
  anyHandle :=  myRecordList.GetFromTitle('Abc').Handle

  // Löschen
  myRecordList[Idx].Delete;
  myRecordList[ myRecordList.GetFromTitle('Abc').Index ].Delete;
end.

So eine (fasst) fertige oder ähnliche Klasse gibt es nicht in Delphi gelle ?

[BUG]

Klingt irgendwie nach einem Dictionary, besonders wenn du denn Index nur zum Durchlaufen brauchst.

[patti]

Hm, spontan würde mir da ein Assoziatives Array oder eine Hashtable einfallen, allerdings kenn ich keine Implementierungen dafür in Delphi und ich weiß auch nicht, ob man dann zusätzlich zum Schlüssel auch noch per Index auf die einzelnen Elemente zugreifen kann...

Edit: BUG war mit seinem Dictionary schneller. Das scheint alle Anforderungen zu erfüllen - und baut auf dem Hashtable-Prinzip auf

[turboPASCAL]

Hm, so etwas "fettes" wollt ich ja nun nicht.

Ich muss mal sehen ob man da was von TStringlist o.ä. ableiten kann.

[BUG]

Evtl. ist funktioniert Objects in TStringList.

[brechi]

Für String und Integer kann man wirklich eine TStringList mit Objects missbrauchen
AddObject('test', Pointer(1234));

[BUG]

Zitat von brechi:

Für String und Integer kann man wirklich eine TStringList mit Objects missbrauchen
AddObject('test', Pointer(1234));

Oder eben Zeiger auf Records

[brechi]

Dann muss man die Records aber selber wieder verwalten (dyn Array etc.) insbesondere beim loaeschen einzelner Items. Dann doch lieber eine eigene Klasse mit TObjectList

[dataspider]

Hi,

dafür bietet sich ein Array Property an.
Allerdings würde ich das auch über eine Klasse lösen, ungefähr so:

Delphi-Quellcode:

unit MyClasses;

interface

uses
  Contnrs, SysUtils;

type
  TItem = class(TObject)
  private
    FTitel: string;
    FHandle: Integer;
  public
    property Titel: string read FTitel write FTitel;
    property Handle: Integer read FHandle write FHandle;
  end;

type
  TItemList = class(TObject)
  private
    FItems: TObjectList;
    function GetItems(Index: Integer): TItem;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(const ATitel: string; AHandle: Integer);
    procedure Clear;
    function Count: Integer;
    function ItemByName(AName: string): TItem;
    property Items[Index: Integer]: TItem read GetItems;
  end;

implementation

constructor TItemList.Create;
begin
  inherited;
  FItems := TObjectList.Create(True);
end;

destructor TItemList.Destroy;
begin
  FItems.Free;
  inherited Destroy;
end;

procedure TItemList.Add(const ATitel: string; AHandle: Integer);
Var
  AItem: TItem;
begin
  AItem := TItem.Create;
  AItem.Titel := ATitel;
  AItem.Handle := AHandle;
  FItems.Add(AItem);
end;

procedure TItemList.Clear;
begin
  FItems.Clear;
end;

function TItemList.Count: Integer;
begin
  Result := FItems.Count;
end;

function TItemList.GetItems(Index: Integer): TItem;
begin
  Result := TItem(FItems[Index]);
end;

function TItemList.ItemByName(AName: string): TItem;
Var
  i: Integer;
begin
  Result := nil;
  for i := 0 to Count - 1 do
  if SameText(FItems[i], AName) then
  begin
    Result := Items[i];
    Exit;
  end;
end;

end.

Ich glaube nur, dass Delphi 6 noch keine TObjectList hatte, oder?
Dann muss natürlich ein TList herhalten, und beim Delete und Clear die Freigabe des Objektes mit erfolgen.

Frank

[Aphton]

Ich weiß nicht, wie die Methode heißt, die ich gleich vorschlagen werde; ich vermute, es ist das, was bei Post #3 angesprochen wurde und zwar Hashtable. Falls es das ist, dann tut mir die Redundanz Leid

Du legst ein Array fester Größe an und schreibst dir eine Hashfunktion, die einen Maximalwert = Größe des Arrays zurückliefert. Beispiel:

Delphi-Quellcode:

MeinArray: Array[0..255] of ...;
funciton MyHashFunc(const Str: String): Byte; // liefert 0..255 zurück

Der Hash gibt den Index zum Array.

Wenn ich zb. 'ABC' habe und der Hash davon 1 ist, dann habe ich folgendes:

Code:

MeinArray[1] = 'ABC'

So, wenn nun ein weiteres Element, 'BCD', denselben Hash, 1, zurückliefert, dann füge ich es hinzu.

Code:

MeinArray[1].Next = 'BCD'

Dazu müsste man einfach eine einfach-verkettete Liste als Element verwenden.

Und wenn man nun ein Element (schnell) suchen möchte, berechnet man den Hash davon, schaut im Array nach, welches Element der Liste es ist und liefert es dann halt als Ergebnis zurück

Edit: Beim nochmaligen Lesen ist mir aufgefallen, dass du Arrays meiden möchtest.
Mit dieser Methode hier wird es aber leichter und effizienter, nach Strings zu suchen.
Falls es trotzdem nicht so das Wahre ist, dann macht das auch nichts