Verschiedene Arrays! Besser mit Generics?

[Mavarik]

das Problem ist doch nicht wie es gespeichert wird...

Sondern wie es definiert ist... Und zwar als Konstanten

[Union]

Dann musst Du eben die Definition ändern. Bisher

Delphi-Quellcode:

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

Ersetzen durch (ähnlich wie ein Dataset)

Delphi-Quellcode:

TMyRecordDef = class(TRecordDef)
...
MyRecordDef := TMyRecordDef.Create;
MyRecordDef.ID := '';
MyRecordDef.AddDefinition('FeldName', ftString, 20);
MyRecordDef.AddDefinition('Feldtype', TFeldTypen);

[Der schöne Günther]

Ich habe es mehrmals versucht und ich habe mir Mühe gegeben, aber ich verstehe immer noch nicht, um was es überhaupt geht

Man erstellt lokal einen Record (mit vielen Feldern) und möchte ihn nun in einen definierten "Default"-Zustand bringen, oder?

Man kann einem Record doch einen (nicht parameterlosen) Konstruktor verpassen und lässt es dort machen? Und - was ich schon immer fragen wollte - was hat es eigentlich mit dem "Default"-Befehl auf sich? Kann man da etwas anpassen oder festlegen, was Default sein soll?

Delphi-Quellcode:

type
   TMyRecord  = record
      someIntField: Integer;
      someStrField: String;
   end;
var
   myRecord: TMyRecord;
begin
   myRecord := Default(TMyRecord);
   [...]
end;

[himitsu]

Sieh das Default einfach wie ein New, nur ohne Pointer dazwischen.

Wenn man bei einfachen Typen anfängt, wird es vielleicht klarer.

Delphi-Quellcode:

Default(Integer) = 0  // Low(Integer)=MinInt und High(Integer)=MaxInt
Default(String) = ''  // Low(String)=erster Array-Index und High(String)=letzer Array-Index
Default(TButton) = nil

Und das kann man nun verschachteln (Default(TMyRecord) ),
wobei quasi für jedes Feld des angegebenen Records das Default des entsprechenden Typen eingesetzt wird.
(im Prinzip entspricht es dem InitializeRecord/InitializeArray aus der SysUils)

[Der schöne Günther]

Ja, mir war nur gruselig, dass ich in der Hilfe zu dumm war, überhaupt etwas zum Ausdruck "Default" zu finden und auch keinen RTL-Code. Dass der alle Record-Felder so initialisiert, wie sie es bsp. in einer Klasse wären war mir schon klar. Nur vielleicht ließe sich das auch manuell noch für einen eigenen Record-Typen anpassen? Man weiß ja nie

[Mavarik]

Zitat von Union:

Delphi-Quellcode:

TMyRecordDef = class(TRecordDef)
...
MyRecordDef := TMyRecordDef.Create;
MyRecordDef.ID := '';
MyRecordDef.AddDefinition('FeldName', ftString, 20);
MyRecordDef.AddDefinition('Feldtype', TFeldTypen);

So könnte man es sicherlich auch machen.
Dann habe ich aus der Konstantendefinition mit 0 Taktzyklen eine aktive Zuweisung mit 10000n Taktzyklen gemacht.
So mache ich für die Zuweisung einen Move - und bin fertig.
Ich habe von diesen Definitionen ca. 25 in allen größen von Array[0..2] bis Array[0..350].
Da ich im OnCreate meines Datenbank Objects diese Definition setzen muss, müsste ich jedes mal durch so eine Liste laufen.
Sorry, aber Mobile_Apps sind schon langsam genug... Mein Weg funktioniert ja.

Dachte nur man könnte es ggf. etwas schöner machen...

Ich dachte eher sowas wie

DoSetArray<T>(MyRecord:T) irgendetwas... Um die Typenzuweisung hin zu bekommen.

Aber ein Generic Type läßt sich scheinbar auch nicht als Konstante definieren, oder doch?

[Union]

Wie hast Du denn die Taktzyklen auf dem Mobilgerät gemessen? Daran wäre ich auch mal sehr interessiert.

[Furtbichler]

Zitat von Mavarik:

Dann habe ich aus der Konstantendefinition mit 0 Taktzyklen eine aktive Zuweisung mit 10000n Taktzyklen gemacht.
So mache ich für die Zuweisung einen Move - und bin fertig.

Bau Dir einfach eine Init-Routine, die das Move kapselt. Das sieht gut aus und der einzig unsichere Code ist in einer einzigen Routine. Die kannst du dann noch als unsicher kommentieren und auf die Gefahren hinweisen mit dem Referenzzähler hinweisen und später vielleicht doch sauber umsetzen (auch wenns nen Takt länger dauert):

Delphi-Quellcode:

procedure InitializeRecord(var recordDef : TRecordDef;  const setupData : Array Of TMyRecordDef);
Begin
  Setlength(RecordDef, Length(setupData));
  Move(setupData[0], RecordDef[0], SizeOf(setupData));
End;

Der Trick ist der open array parameter 'Array Of TMyRecordDef'. Das ist hier kein dynamisches Array, sondern eben irgend ein 'Array Of TMyRecordDef'. Der Compiler macht das schon richtig. Und aufrufen geht ganz einfach

Delphi-Quellcode:

Begin
  InitializeRecord (myNewRecordDef, SetupDataWith150Values);
  InitializeRecord (myOtherRecordDef, SetupDataWith2Values);

Das ist genau das, was himitsu schon vorgeschlagen hat.

Übrigens (Tipp): Hör auf mit dem Takte zählen. Auch wenn so ein Mobilteil nicht das schnellste ist (1Ght Takt, pff), *dabei* geht garantiert keine Zeit flöten, sondern eher mit Swapping, Dateizugriffen, schlechten Algorithmen, miesen Datenbankabfragen, schrottigen GUI-Frameworks und dergleichen. Aber ich lass mich natürlich gerne belehren.

[Mavarik]

Zitat von Furtbichler:

Übrigens (Tipp): Hör auf mit dem Takte zählen. Auch wenn so ein Mobilteil nicht das schnellste ist (1Ght Takt, pff), *dabei* geht garantiert keine Zeit flöten, sondern eher mit Swapping, Dateizugriffen, schlechten Algorithmen, miesen Datenbankabfragen, schrottigen GUI-Frameworks und dergleichen. Aber ich lass mich natürlich gerne belehren.

Nee gerade nicht. Wenn alle mal sich ein bisschen darauf besinnen würden, dass ein Move schneller ist als 100 Zuweisungen und es den Leuten weniger darum gehen würde ob der Code schön aussieht! Hätten wir die gleich Geschwindigkeit z.B. unter Windows mit der halben Taktfrequenz.

Wenn ich mir anschaue wie oft in der RTL etwas erzeugt wird dann der Free um kurz darauf es wieder zu erzeugen. Oder wie oft ein Speicherbereich kopiert wird usw... Gruselig.

Aber Du hast schon Recht. Optimierung hat nicht mehr den Stellenwert wie früher. Nur wenn ich mit wenigen Handgriffen optimieren kann, mach ich das auch.

[DeddyH]

Nichts gegen Optimierung, aber nicht auf Kosten der Sicherheit. Zumindest mir persönlich ist ein Programm lieber, dass etwas langsamer stabil läuft als eins, das etwas schneller abschmiert.