Verschachtelte array of record Initialisierung

[Codehunter]

Hallo!

Ich möchte ein in sich verschachteltes array of record in einer Konstantendeklaration initialisieren. In der ersten Ebene kein Problem, in der zweiten mag der Compiler nicht mitziehen:

Delphi-Quellcode:

type
  TheItemKind = (ikNone, ikCheckBox, ikCheckListBox, ikComboBox, ikEdit, ikGroupBox, ikIPAddress, ikSpinEdit);

  TheControlItemDef = record
    Caption: string;
    Kind: TheItemKind;
    KonfigPath: string;
    Childs: array of TheControlItemDef;
  end;

const
  ITEMDEFS: array[0..2] of TheControlItemDef = (
    (Caption: 'Edit1'; Kind: ikEdit; KonfigPath: 'Edit1'),
    (Caption: 'Spin1'; Kind: ikSpinEdit; KonfigPath: 'Spin1'),
    (Caption: 'Gruppe1'; Kind: ikGroupBox; KonfigPath: ''; Childs: (
      (Caption: 'Checker1'; Kind: ikCheckBox; KonfigPath: 'Check1'), // <-- Nach "Caption": "E2029 ')' erwartet, aber ':' gefunden"
      (Caption: 'Checker2'; Kind: ikCheckBox; KonfigPath: 'Check2')
    ))
  );

Ist das innerhalb einer einzigen Konstantendeklaration überhaupt möglich oder muss ich für die Childs erst eine eigene Konstante initialisieren und dann diese Konstante einem Childs-Property zuweisen?

Ziel soll eigentlich sein, eine möglichst kompakte Initialisierung im Code zu haben.

Grüße
Cody

[DeddyH]

AFAIK kann man für dynamische Arrays keine Konstanten definieren.

[Codehunter]

Zitat von DeddyH:

AFAIK kann man für dynamische Arrays keine Konstanten definieren.

Hmmm... Das hier klappt aber:

Delphi-Quellcode:

type
  TheItemKind = (ikNone, ikCheckBox, ikCheckListBox, ikComboBox, ikEdit, ikGroupBox, ikIPAddress, ikSpinEdit);

  TheControlItemDef = record
    Caption: string;
    Kind: TheItemKind;
    KonfigPath: string;
    Childs: array of TheControlItemDef;
  end;

const
  ITEMDEFS: array[0..1] of TheControlItemDef = (
    (Caption: 'Edit1'; Kind: ikEdit; KonfigPath: 'Edit1'),
    (Caption: 'Spin1'; Kind: ikSpinEdit; KonfigPath: 'Spin1')
  ); 

procedure TuWas(MyArray: array of TheControlItemDef);

implementation

procedure TForm1.Button1Click(Sender: TObject);
begin
  TuWas(ITEMDEFS);
end;

procedure TuWas(MyArray: array of TheControlItemDef);
var
  LItem: TheControlItemDef;
begin
  for LItem in MyArray do {...};
end;

[DeddyH]

ITEMDEFS ist ein statisches Array, MyArray ein offenes

[Blup]

Childs ist hier ein dynamisches Array, genauer eine Pointer-Variable die auf einen Speicherbereich zeigt, in dem die Daten des dynamische Arrays im Speicher liegen. IDie Initialisierung kann eigentlich nur durch Zuweisung eines geeigneten Arrays erfolgen.

ITEMDEFS ist ein konstantes Array fester Größe.
MyArray ist als Parameter ein offenes Array, wieder etwas anderes.

Vieleicht kannst du die Struktur zu einer flachen Liste umbauen, wenn bei den Checkboxen als zusätzliche Info der jeweilige "Parent" angegeben wird.

[Codehunter]

Na gut, ich bin ja auch nicht zwingend darauf angewiesen, das Ganze im Interface-Teil zu machen. Ich könnte mir das auch innerhalb einer class static function vorstellen. Schön wäre wenn man anhand der Quelltextstruktur auch schon die spätere Elementstruktur erkennbar wäre, wie hier mit ITEMDEFS beispielhaft gezeigt. Was könnte man dafür praktischerweise verwenden?

[Zacherl]

Probier mal eckige statt offene Klammern für das innere Array. Nur sone Idee.

[Uwe Raabe]

Zitat von Zacherl:

Probier mal eckige statt offene Klammern für das innere Array. Nur sone Idee.

Ist zwar ein guter Ansatz, aber funktioniert leider nicht.

Folgendes könnte man zur Laufzeit machen:

Delphi-Quellcode:

type
  TheItemKind = (ikNone, ikCheckBox, ikCheckListBox, ikComboBox, ikEdit, ikGroupBox, ikIPAddress, ikSpinEdit);

  TheControlItemDef = record
    Caption: string;
    Kind: TheItemKind;
    KonfigPath: string;
    Childs: TArray<TheControlItemDef>;
  public
    constructor Create(const ACaption: string; AKind: TheItemKind; const AKonfigPath: string; AChilds: TArray<TheControlItemDef> = nil);
  end;

constructor TheControlItemDef.Create(const ACaption: string; AKind: TheItemKind; const AKonfigPath: string; AChilds: TArray<TheControlItemDef> = nil);
begin
  Caption := ACaption;
  Kind := AKind;
  KonfigPath := AKonfigPath;
  Childs := AChilds;
end;

function Initialize: TArray<TheControlItemDef>;
begin
  Result := TArray<TheControlItemDef>.Create(
    TheControlItemDef.Create('Edit1', ikEdit, 'Edit1'),
    TheControlItemDef.Create('Spin1', ikSpinEdit, 'Spin1'),
    TheControlItemDef.Create('Gruppe1', ikGroupBox, '',
      TArray<TheControlItemDef>.Create(
        TheControlItemDef.Create('Checker1', ikCheckBox, 'Check1'),
        TheControlItemDef.Create('Checker2', ikCheckBox, 'Check2')
      )
    )
  );
end;

[himitsu]

Zitat von Zacherl:

Probier mal eckige statt offene Klammern für das innere Array. Nur sone Idee.

Eine Variable in einer Konstante ... kann nicht gehn.

Delphi kann zwar inzwischen die Länge der statische Array-Konstanten automatisch bestimmen, also ohne explizite Angabe der Länge,
aber das gilt nur für die oberste Ebene, bzw. muß einheitlich für die Unteren sein, denn innerhalb eines Arrays müssen alle Felder gleich lang sein.
> Array-Konstante in Array-Konstante mit unterschiedlichen Längen geht nicht, da sonst für jedes Feld eine eigene TypeInfo/RTTI notwendig wäre.






Rein technisch wäre es möglich, dass man auch für dynamische Arrays eine Konstante definiert, so wie es auch bei Strings geht (welche intern auch nur dynamische Arrays sind),
aber da bei dynamischen Arrays das CopyOnWrite nicht funktioniert (seit Jahren vergessen wurde) und somit die Referenzbehandlung diesbezüglich nicht korrekt arbeiten kann, so dürft ihr das vergessen.
(Konstante ist RefCount=-1)

[Codehunter]

Manchmal braucht es nur einen kleinen Schubs. Und der Uwe kann sehr effektiv schubsen Generics sind schon was feines. So funktionierts:

Delphi-Quellcode:

type
  TheItemKind = (ikNone, ikCheckBox, ikCheckListBox, ikComboBox, ikEdit, ikGroupBox, ikIPAddress, ikSpinEdit);

  TheControlItemDef = record
    Caption: string;
    Kind: TheItemKind;
    ConfigPath: string;
    Childs: TArray<TheControlItemDef>;

    class function Create(const ACaption, AConfigPath: string; const AKind: TheItemKind; AChilds: TArray<TheControlItemDef> = []): TheControlItemDef; static;
  end;

  TheControlItemDefs = TArray<TheControlItemDef>;

implementation

{ TheControlItemDef }

class function TheControlItemDef.Create(const ACaption, AConfigPath: string;
  const AKind: TheItemKind;
  AChilds: TArray<TheControlItemDef>): TheControlItemDef;
begin
  Result.Caption := ACaption;
  Result.ConfigPath := AConfigPath;
  Result.Kind := AKind;
  Result.Childs := AChilds;
end;

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
var
  ITEMDEFS: TheControlItemDefs;
begin
  ITEMDEFS := TheControlItemDefs.Create(
    TheControlItemDef.Create('Edit1', 'Edit1', ikEdit),
    TheControlItemDef.Create('Spin1', 'Spin1', ikSpinEdit),
    TheControlItemDef.Create('Gruppe1', 'Gruppe1', ikGroupBox, TheControlItemDefs.Create(
      TheControlItemDef.Create('Checker1', 'Checker1', ikCheckBox),
      TheControlItemDef.Create('Checker2', 'Checker2', ikCheckBox)
    ))
  );
end;

(Über den ConfigPath-Member mal keine Gedanken machen, das ist fallpezifisch)

Und es gibt so auch keine Memleaks am Ende. Bin begeistert. Zumal diese Variante in der Initialisierung des Arrays noch eleganter wirkt als die ursprüngliche Version und außerdem noch mit dynamischen Arrays. Schick schick

Grüße
Cody