Verschiedene Arrays! Besser mit Generics?

[Mavarik]

Hallo Zusammen.

Gegeben sein folgende Definition:

Delphi-Quellcode:

    TMyRecordDef = record
                     Feldname : String;
                     Feldtype : TFeldtypen;
                   end;

    TRecordDef   = array of TMyRecordDef;

und z.B. folgende Initialisierung:

Delphi-Quellcode:

Const
   SetupRecord  : array[0..1]  of TMyRecordDef = ((Feldname:'Magic';Feldtype:sqKeyText),
                                                  (Feldname:'Wert';Feldtype:sqText));

Leider muss ich jetzt immer folgendes machen:

Delphi-Quellcode:

  Setlength(FRecordDef,length(SetupRecord));
  Move(SetupRecord[0],FRecordDef[0],Sizeof(SetupRecord)); // Feld der Class

Weil die Typen nicht kompatible sind.

Da gibt es doch sicherlich ne "hübsche" Umgehung durch Generics, oder?

Mavarik

[Daniel]

Wenn Du wirklich eine tiefe Kopie haben möchtest und nicht nur Referenzen durch die Gegend schubsen magst, könntest Du Deinem Record beispielsweise eine Assign()-Methode spendieren, wie man sie etwa auch bei einer TStringList findet.

[Furtbichler]

Ich glaube, das man hier keine Generics verwenden kann. Das von Dir beschriebene Problem ist eine Schwachstelle von Delphi, nämlich das Vorhandensein von zwei scheinbar identischen Datenstrukturen: statisches vs. ein dynamisches Array.

Bei Dir ist ja nur rein zufällig FRecordDef genauso groß wie SetupRecord, ergo solltest du das eine Array in das andere kopieren, ohne das blöde Move zu verwenden, also warum nicht banal?

Delphi-Quellcode:

FRecordDef[0] := SetupRecord[0];
FRecordDef[1] := SetupRecord[1];

oder allgemein:

Delphi-Quellcode:

Procedure InitializeRecordDef(Var recordDef : TRecordDef);
Var
  i : Integer;

Begin
  SetLength (recordDef, Length(SetupRecord));
  for i:= low(SetupRecord) to High(SetupRecord) do recordDef[i]:=SetupRecord[i];
End;

[Mavarik]

Zitat von Furtbichler:

ergo solltest du das eine Array in das andere kopieren, ohne das blöde Move zu verwenden, also warum nicht banal?

Warum soll ich ne for schleife nehmen, wenn der Move das gleiche macht nur in einem Bruchteil der Zeit?

[Furtbichler]

Zitat von Mavarik:

Zitat von Furtbichler:

ergo solltest du das eine Array in das andere kopieren, ohne das blöde Move zu verwenden, also warum nicht banal?

Warum soll ich ne for schleife nehmen, wenn der Move das gleiche macht nur in einem Bruchteil der Zeit?

Logisch, würde ich normalerweise auch so machen (Obwohl das mit dem Bruchteil so ne Sache ist, aber im Prinzip haste Recht). Ich dachte eher an diese perversen String-Referencecounter. Keine Ahnung, ob beim Move dabei alles koscher bleibt.

[Uwe Raabe]

Zitat von Furtbichler:

Ich dachte eher an diese perversen String-Referencecounter. Keine Ahnung, ob beim Move dabei alles koscher bleibt.

Dachte ich auch erst, aber die Strings sind ja faktisch Konstanten. Konstante Strings haben aber als RefCount immer -1 und der wird auch nicht verändert.

Normalerweise ist der Move-Befehl bei Records mit ref-counted Feldern ein No-Go. Deshalb würde ich ihn auch in diesem speziellen Fall nicht verwenden.

BTW - Man kann es auch so machen:

Delphi-Quellcode:

Procedure InitializeRecordDef(Var recordDef: TRecordDef);
Begin
  recordDef := TRecordDef.Create(SetupRecord[0], SetupRecord[1]);
End;

[himitsu]

Zitat von Mavarik:

Leider muss ich jetzt immer folgendes machen:

Delphi-Quellcode:

  Setlength(FRecordDef,length(SetupRecord));
  Move(SetupRecord[0],FRecordDef[0],Sizeof(SetupRecord)); // Feld der Class

Nein, das musst du nicht, denn wenn du das machst, dann versohl' ich dir den Arsch!

Denn du schrottest damit die Referentzählung des String .

[Uwe Raabe]

Zitat von himitsu:

Denn du schrottest damit die Referentzählung des String .

Das stimmt eben genau in diesem Fall nicht!

Stringkonstanten haben einen Referenzzähler von -1, der auch nicht verändert wird. Mit dem Move-Befehl wird ja auch nicht der String kopiert, sondern nur der Zeiger darauf. Für den weiteren Programmablauf verhält sich das Stringfeld im Record genauso als ob man die Konstante direkt zugewiesen hätte. Für nicht-konstante Strings hättest du natürlich Recht, weswegen ich diesen Code auch eher als Hack ansehe.

Du kannst Mavarik also unbehelligt lassen... (obwohl, eine Kopfnuss wäre vielleicht doch angebracht)

[himitsu]

Das ist aber auch nur Zufall, wenn es hier zufällig geht.

FRecordDef muß vorher leer sein, also es darf wirklich nichts in [0] stehen
und in dem SetupRecord müssen "echte" String-Konstanten (RefCount = -1) drin stecken.

Aber seit diesen komischen mobilen Compilern sollte man dem Braten nicht mehr so einfach trauen.
(die haben schon unsere schöne Delphi-1 geschrottet ... wer weiß was die sonst noch machen)


Nja, und wer weiß wo er sonst noch solchen Code verwendet?
Am Ende ist es doch so, daß man später wieder irgendwo sowas braucht, dann copy&pastet man es und schwup, an der Stelle war das dann natürlich zufällig falsch.


InitializeRecord, FinalizeRecord und CopyRecord, bzw. XxxxxxArray mit Anzahl 1 und schon nutzt man die richtigen Methoden, (siehe Unit System)
wenn man ungedingt manuell Kopieren machen will.
Oder man weist direkt die Records via := und überläßt es dem Compiler. Es ist ja nicht so, daß der native Code hier sooooooooooooo lahm wäre.



Hey, nun, wo man endlich Record-Helper auch nativen Typen zuweisen kann, wäre ein

Delphi-Quellcode:

type
  TRecordDefHelper = record helper for TRecordDef 
    procedure Assign(const Values: array of TMyRecordDef);  // Code siehe InitializeRecordDef in #3
    //procedure Add(...
    //procedure Delete(...
    //...
  end;

FRecordDef.Assign(SetupRecord);

doch ganz nett? (geht aber erst seit XE4 oder so )

[Mavarik]

Zitat von Uwe Raabe:

Delphi-Quellcode:

Procedure InitializeRecordDef(Var recordDef: TRecordDef);
Begin
  recordDef := TRecordDef.Create(SetupRecord[0], SetupRecord[1]);
End;

Mit den 2 Feldern geht das ja noch... Aber andere Records haben 100 Felder!