Eigenen Typ in Klasse

[zer00]

Hi all

Ich möchte in einer eigenen Klasse einen Record-Typ in einem Dynamischen Array speichern, nun sollte aber der Record-Typ auch von aussen sichtbar sein.
Der User der Klasse soll eine neue Variable des Record-Typs deklarieren können und diese dann an eine Methode der Klasse übergeben.
z.B. so:

Delphi-Quellcode:

var Foo: TRecord;
Klasse.Add(foo);

Leider habe ich keine Ahnung wie ich das in meiner Klasse implementieren muss.

grz zer00

[arbu man]

Deine add proc könnte so aussehen:

Delphi-Quellcode:

procedure tetc.add(foo: Tdeinrecord);
begin
  setlength(derarray, length(derarray)+1)
  derarray[length(derarray)]:= foo;
end;

(aus dem kopf)

[r2c2]

So vielleicht:

Delphi-Quellcode:

TRecord = record
  Data: string;
  Data2: Integer;
end;

TTest = class(TObject)
private
  FData: TList;
public
  constructor Create;
  destructor Detroy; override;
  property: Data: TList read FData write FData;
  procedure Add(Data: TRecord);
end;

constructor TTest.Create;
begin
  inherited Create;
  FList := TList.Create;
end;

destructor TTest.Destroy;
begin
  FList.Free;
  inherited Destroy;
end;

procedure TTest.Add(Data: TRecord);
begin
  FData.Add(@Data);
end;

Quellcode ungetestet. Nur so runtergetippt. Auch die Speicherverwaltung der Records(new, dispose) fehlt noch. Sollte aber so ne Idee von dem geben, wie das aussehen könnte. BTW: Warum willst du eigentlich n Record nehmen? Warum nicht auch ne Klasse. Dann könntest du dir die Speicherverwaltung nämlich schenken(TObjectList, ggf. + Template).

mfg

Christian

[chaoslion]

mal ne Frage, ist es nicht "sicherer", alle Daten eines Records exakt zu übertragen, also

Delphi-Quellcode:

procedure add( foo: trec );
begin
 self.arrayoftrec[..].t1 := foo.t1;
 self.arrayoftrec.t2 := foo.t2;
end;

anstatt zu sagen:

Delphi-Quellcode:

...
 self.arrayoftrec[...] := foo;
...

??

[r2c2]

Zitat:

Zitat von chaoslion

mal ne Frage, ist es nicht "sicherer", alle Daten eines Records exakt zu übertragen?

Warum? :gruebel: Wenn du die selbe Record-Deklaration hast und alles andere wäre...ähm...komisch, dann is die andere Variante nur mehr Schreibarbeit und muss dazu noch jedes Mal, wenn sich der Record-Typ ändert, neu angepasst werden...

mfg

Christian

[Christian Seehase]

Moin arbu man,

wobei man aus Performance Gründen nicht gerade immer um 1 erhöhen sollte.
Erst einmal auf die zu erwartende Grösse setzen, und beim Hinzufügen prüfen, ob noch Platz ist, dann ggf. um einen bestimmten Wert erhöhen.
Beim Vergrössern mittels SetLength wird jedesmal ein neues Array angelegt, und der Inhalt des alten dort hineinkopiert.

[Hawkeye219]

Auf jeden Fall sollte man nur die gültigen Elemente des Arrays benutzen:

Delphi-Quellcode:

procedure tetc.add(foo: Tdeinrecord);
begin
  setlength(derarray, length(derarray)+1)
  derarray[High(derarray)]:= foo;  // <-- High() statt Length()
end;

Gruß Hawkeye

[Der_Unwissende]

Zitat:

Zitat von Hawkeye219

Auf jeden Fall sollte man nur die gültigen Elemente des Arrays benutzen:

Delphi-Quellcode:

procedure tetc.add(foo: Tdeinrecord);
begin
  setlength(derarray, length(derarray)+1)
  derarray[High(derarray)]:= foo;  // <-- High() statt Length()
end;

Hi,
noch viel besser ist es, hier einfach gar kein Array zu verwenden. Ein Array ist nun mal eine recht statische Struktur und

Delphi-Quellcode:

setLength(Array, length(Array) + 1);

ist nicht wirklich empfehlenswert (kostet unnötig Zeit und wird vom Speichermanager nicht unbedingt optimal gelöst). Viel besser ist es, wenn du einfach eine TList verwendest, die ist genau dafür gedacht. An sich kannst du deine Records viel schöner als Pointer auf den Record übergeben (ist schneller) und diesen Pointer kannst du dann in deiner TList speichern. Wenn du lesend auf das Array zugreifst, dann kannst du hier ganz einfach eine Methode anlegen, die die TList in ein Array umwandelt. Schreibend kannst du auch Wahlfrei auf die TList zugreifen.

Gruß Der Unwissende

[r2c2]

Zitat:

Zitat von Der_Unwissende

Viel besser ist es, wenn du einfach eine TList verwendest, die ist genau dafür gedacht. An sich kannst du deine Records viel schöner als Pointer auf den Record übergeben (ist schneller) und diesen Pointer kannst du dann in deiner TList speichern. Wenn du lesend auf das Array zugreifst, dann kannst du hier ganz einfach eine Methode anlegen, die die TList in ein Array umwandelt. Schreibend kannst du auch Wahlfrei auf die TList zugreifen.

Den Vorschlag kenn ich doch irgendwo her... :stupid: :mrgreen:

mfg

Christian

[zer00]

Danke für die vielen Antworten!
Sehe ich das richtig, dass ich mein Problem am besten mit einer Verketteten Liste löse.
Da ich aber noch nie viel mit Pointern gearbeitet habe werde ich sicher noch ein paar Fragen an euch haben.
Bitte habt ein bisschen Geduld. ;)

grz zer00