Record und Array forwarded deklarieren

[Flogo]

Ich bin vor kurzem über folgende Konstruktion gespolpert:

Delphi-Quellcode:

type
  TMyArray = array of TMyRecord;
  
  TMyRecord = record
    [..]
    flomp: TMyArray;
  end;

In meinem Fall hat sich das schon geklärt, weil ich nur Pointer im Record benutzen kann, aber ist so was rein theoretisch möglich? Gibt es irgendein TMyArray = arrray; forward; oder etwas in der Art?

[Minz]

Vorweggenommen, ich weiß es nicht, ob es sowas gibt aber:

es erscheint mir problematisch eine solche Konstruktion zuzulassen, da sie eine unendliche Liste von Records erzeugen würde, nicht nur unendlich in der Länge, auch in den Dimensionen !

Delphi-Quellcode:

TMyRecord=record
   x: integer;
   y: integer;
   f: array of TMyRecord;
end;

x, y ,f[0].x, f[0].y, f[1].x, f[1].y, ..., f[n].x, f[n].y
     aber auch:       f[0].f[0].x, f[0].f[0].y, f[0].f[1].x, f[0].f[1].y, ...,f[0].f[n].x, f[0].f[n].y
                      f[1].f[0].x, f[1].f[0].y, f[1].f[1].x, f[1].f[1].y, ...,f[1].f[n].x, f[1].f[n].y
                      .
                      .
                      .
                      f[n].f[0].x, f[n].f[0].y, f[n].f[1].x, f[n].f[1].y, ...,f[n].f[n].x, f[n].f[n].y
     aber auch:       f[0 bis n].f[0 bis n]...
                      f[0 bis n].f[0 bis n].f[0 bis n]...
                      .
                      .
                      .

n=unendlich

Eine solche unendlich komplexe Struktur - wer kann sie brauchen?

[sniper_w]

Unendlich wirds sicherlich nicht sein. Ich sehe kein Problemm damit.

[alzaimar]

Doch, es ist unendlich. Du versuchst zwar, mit einem dynamischen Array das Problem der Unendlichkeit zu umgehen (Dein 'flomp' ist ja in Wirklichkeit ein Pointer), aber Delphi lässt das eben nicht zu(Aus gutem Grund). Was du machen willst, ist Folgendes;

Delphi-Quellcode:

Type
  PMyRecord = ^TMyRecord; // erlaubt, obwohl TMyRecord noch nicht definiert ist
  TMyRecord = Record
    mrFoo : Integer;
    mrBar : Array of PMyRecord;
    End;

Jetzt kann man die Größe des TMyRecord angeben (4008 Bytes). Bei Klassen hingegen wäre deine Deklaration ok, weil TMyClass sowohl die Klasse, als auch den Verweis bezeichnet.

Delphi-Quellcode:

TMyClass = Class
private
  fFoo : Integer;
  fBar : Array Of TMyClass;
...
end;

[Minz]

@sniper
versuch mal meine Auflistung zu verstehen, ist ein bissel vewirrend und auch mathematisch nicht ganz korrekt notiert, aber nachvollziehbar ...

Angenommen du hast

T: TMyRecord;

dann hast du:

T.x
T.y
aber auch
T.f

weil T.f ja vom Typ TMyRecord ist, heißt das du hast:

T.f.x
T.f.y
aber auch
T.f.f

usw., also unendlich.

Da in dem Beispiel aber f nicht einfach nur TMyRecord ist, sondern noch ein Array von TMyRecord, ist nicht nur die Länge unendlich, sondern auch die komplexität bwz. die Dimensionen. Die Auflistung versucht das deutlich zu machen.

[Flogo]

Zitat von alzaimar:

Doch, es ist unendlich. Du versuchst zwar, mit einem dynamischen Array das Problem der Unendlichkeit zu umgehen (Dein 'flomp' ist ja in Wirklichkeit ein Pointer), aber Delphi lässt das eben nicht zu(Aus gutem Grund). Was du machen willst, ist Folgendes;

Delphi-Quellcode:

Type
  PMyRecord = ^TMyRecord; // erlaubt, obwohl TMyRecord noch nicht definiert ist
  TMyRecord = Record
    mrFoo : Integer;
    mrBar : Array of PMyRecord;
    End;

So hab ich das auch gelöst (musste ich weil Records mit Variant-Teil nur Pointer auf Records, Arrays und Objekte zulassen)

Aber ich denke trotzdem nicht das mein Beispiel zwangsläufig unendlich werden würde. Angenommen ich habe am Anfang ein Record (R).
Dann habe ich da drin auf jeden Fall ein Array (R.A)
Diesem Array kann ich zum Beispiel die Länge 2 geben. Dadurch bekomme ich 2 neue Records (R.A[0] und R.A[1])
Jeder dieser Records hat wieder ein Array (R.A[0].A und R.A[1].A) Wenn ich jetzt aber diesen beiden Arrays die Länge 0 gebe, hört es hier auf.
Es würde sich doch theoretisch ein Baum bilden der an jedem Knoten (Record) so viele neue Äste hat wie das Array (Length(Array)). Am Ende dieses Baumes hat man überall ein Array der Länge 0.

[Robert Marquardt]

Innerhalb ein und des selben Type-Abschnitts ist so eine Forward-Deklaration zulaessig.
"array of" ist die Deklaration eines Zeigers. Damit ist die Groesse des Elementes flomp innerhalb des Records aber bekannt.
Die Alloziierung der Elemente von flomp erfolgt spaeter im Code mit dem Aufruf von SetLength().

[Flogo]

Delphi-Quellcode:

type
  TMyArray = array of TMyRecord;
  
  TMyRecord = record
    [..]
    flomp: TMyArray;
  end;

liefert bei mir aber den Fehler [Error] Unit1.pas(11): Undeclared identifier: 'TMyRecord'

Delphi-Quellcode:

type
  TMyRecord = record
    [..]
    flomp: array of TMyRecord;
  end;

Hier kommt [Error] Unit1.pas(12): Type 'TMyRecord' is not yet completely defined

Muss man da noch irgendwas kennzeichnen, damit das erlaubt wird?

[alzaimar]

Zitat:

Muss man da noch irgendwas kennzeichnen, damit das erlaubt wird?

Vergiss es. Delphi sagt Dir doch klipp und klar, das es *nicht* geht. Es ist nicht erlaubt. Du kannst ja nun mal auch keine multiplen Zuweisungen, wie z.B. A:=B:=C:=D; machen, obwohl es eigentlich möglich wäre.

[Flogo]

Die Frage bezog sich auf den Post von Robert Marquardt

Zitat von Robert Marquardt:

Innerhalb ein und des selben Type-Abschnitts ist so eine Forward-Deklaration zulaessig.

Wenn er meint das ist möglich dann würde ich eben gerne wissen wie. So oft brauch man sowas zwar nicht und wenn doch kann man ja immer noch den Umweg mit den Pointern nehmen, aber es wäre doch interessant zu wissen wenn es doch geht.