Generics in Record

[mkinzler]

Versuch es mal mit Klassen. So scheint es zu gehen

Delphi-Quellcode:

unit GTU;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

TRecObj<T> = class
type
  //PRec = ^TRec;
  TRec = class
    ID: integer;
    Data: T;
  end;
private
  FRec: TRec;
public
  constructor Create(ID: integer; Data: T);
  destructor Destroy; reintroduce;
end;

var
  Form1: TForm1;
  myObj: TRecObj<string>;

implementation

{$R *.dfm}

constructor TRecObj<T>.Create(ID: integer; Data: T);
begin
  inherited Create;
  FRec := TRec.Create;
  FRec.ID := ID;
  FRec.Data := Data; // schmeißt AV
end;

destructor TRecObj<T>.Destroy;
begin
  FRec.Destroy;
  inherited Destroy;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
    myObj := TRecObj<string>.Create(-17, 'Hallo');
    Caption := myObj.FRec.Data;
end;

end.

[Hawkeye219]

Hallo Björn,

versuche es einmal mit diesem Ansatz:

Delphi-Quellcode:

uses 
  Generics.Collections;

type
  TRecord<T> = record
    ID: Integer;
    Data: T;
    constructor Init (const aID: Integer; const aData: T);
  end;

  TRecordList<T> = class (TList<TRecord<T>>)
    procedure AddItem (const aID: Integer; const aData: T);
  end;

constructor TRecord<T>.Init(const aID: Integer; const aData: T);
begin
  ID := aID;
  Data := aData;
end;

procedure TRecordList<T>.AddItem(const aID: Integer; const aData: T);
var
  R: TRecord<T>;
begin
  R.Init (aID, aData);
  Add(R);
end;

// Anwendung

var
  MyList: TRecordList<string>;
begin
  MyList := TRecordList<string>.Create;
  try
    MyList.AddItem (42, 'Hallo Welt');
    MyList.AddItem (0, 'EOF');
    ShowMessage (MyList[0].Data);
  finally
    MyList.Free;
  end;
end;

Oder habe ich etwas an deiner Problemstellung übersehen?

Falls die ID eine eindeutige Kennung des Records sein sollte, wäre vielleicht ein Blick auf TDictionary<TKey,TValue> sinnvoll.

Gruß Hawkeye

[Björn Ole]

Danke für eure Tipps.

Habe es jetzt so gelöst:

Delphi-Quellcode:

type
  TItem<T> = class
  private
    FID: integer
    FData: T;
    FNext: TItem<T>;
  public
    constructor Create(AID: integer; AData: T);
    property ID: integer read FID;
    property Data: T read FData;
    property Next: TItem<T> read FNext write FNext;
  end;

  TItemList<T> = class
  type
    TListItem = TItem<T>;
  private
    FFirst: TListItem;
    FLast: TListItem;
    {...}

Damit kann ich bequem weiterarbeiten.