Verschachtelte Arrays und Records

[enigma]

Hallo zusammen,

ich plage mich schon länger mit ineinander verschachtelten Arrays und Records und freue mich über jeden Tipp.

Die Datenstruktur ist die folgende:

Delphi-Quellcode:

TArray1 = array[1..1] of
 record
   String1: String;
// array2: array[1..1] of //mit dieser Länge 1 klappt es, s. unten
   array2: array[1..2] of //mit dieser Länge 2 klappt es nicht, Fehlermeldungen s. weiter unten
   record
     String2: String;
     array3: array[1..4, 1..2] of Double;
   end;
 end;

Diese Definition mit Länge von array2 = 1 klappt:

Delphi-Quellcode:

  array1Arr2Laenge1: TArray1 =
  ( ( String1: 'TestString1';
      array2:
      (
        ( String2: 'TestString2';
          array3:
          ( (1, 2) ,
            (1, 2),
            (1, 2),
            (1, 2)
          ); {array3}
        ) {record}
      ); {array2}
    ) {record}
  ); {array1Arr2Laenge1}

Diese Definition mit Länge von array2 = 2 klappt nicht, Fehlermeldungen beim Übergang von erster zu zweiter Definition von record 2 klappt nicht, s. unten

Delphi-Quellcode:

 
 array1: TArray1 =
  ( {array1}
   ( {record 1}
      String1: 'TestString1';
      array2:
      ( {array2 }
        ( {record 2}
          String2: 'TestString2';
          array3:
          ( (1, 2) ,
            (1, 2),
            (1, 2),
            (1, 2)
          ); {array3}
        ) {record 2}
        //) {Setze ich hier ‘)‘ wie unten gefordert, erscheint}
                                   {Folgende Meldung: „Anzahl der Elemente (1) weicht von der
                                                       Deklaration (2) ab“}
        ( {record 2}       {Meldung „‘)‘ erwartet, aber ‚(‘ gefunden“}
          String2: 'TestString2';
          array3:
          ( (1, 2) ,
            (1, 2),
            (1, 2),
            (1, 2)
          ); {array3}
        ) {record 2}

      ); {array2}
    ) {record 1}
  ); {array1}

Wenn ihr eine Idee habt, lasst sie mich bitte wissen.

[Aviator]

[EDIT] Kann prinzipiell auch sein, dass ich durch die vielen Klammern und dem schnellen Lesen etwas verrutscht bin. Aber das Komma scheint trotzdem zu fehlen. [/EDIT]

Du hast TArray1 als array[1..1] deklariert. Da ist natürlich klar, dass nur ein Element aufgenommen werden kann. Du musst das Array vergrößern. Zusätzlich musst du dann bei der Definition natürlich die Elemente mit Komma trennen.

Unabhängig davon finde ich die Art und Weise wie du das aufziehst allerdings recht unübersichtlich. Warum erstellt du dir nicht separate Record Typen und verweist dann darauf?

Könnte dann in etwa so aussehen. Nur schnell hier im Editor geschrieben:

Delphi-Quellcode:

Record2 = record;
  // Some types
  Data: array of Record3;
  String2: String;
  array3: array[1..4, 1..2] of Double;
end;

Record1 = record
  String1: String;
  Data: array of Record2;
end;

TArray1 = array[1..1] of
 record
   String1: String;
   array2: array of Record1;
 end;

[Der schöne Günther]

Ganz ehrlich, das ist doch nicht mehr im geringsten leserlich. Wenn du es unbedingt als Konstante haben willst darfst du auch nicht durcheinanderkommen:

Delphi-Quellcode:

type
   TArray1 = array [1 .. 1] of record
      String1: String;
      array2: array [1 .. 2] of record
         String2: String;
         array3: array [1 .. 4, 1 .. 2] of Double;
      end;
   end;

const
   array1: TArray1 = (
      (
         String1: 'TestString1';
         array2: (
            (
               String2: 'TestString2';
               array3: ((1, 2), (1, 2), (1, 2), (1, 2));
            )
            ,
            (
               String2: 'TestString2';
               array3: ((1, 2), (1, 2), (1, 2), (1, 2));
            )
         )
      )
   );

PS: Erinnert mich ein bisschen an "LISP" hieraus:
https://toggl.com/blog/save-princess...ming-languages

[enigma]

Vielen Dank für eure Tipps - das Problem ist gelöst.

Manchmal übersieht man eine Kleinigkeit...