Konstanter dynamischer Array <- Möglich?

[SebE]

Delphi-Quellcode:

type
  rec = record
    irgendwas: CHAR;
    liste: array of integer;
    end;

const
  A: array[0..1] of rec = (
    (irgendwas: 'a'; liste: (1, 2, 3, 5, 0)), <- hier mag Delphi meine Syntax nicht
    (irgendwas: 't'; liste: (3, 5, 90))
    );

Problem: Es sieht so aus, als kann man keine konstanten dynamischen arrays erstellen (lassen).

Kann nicht der Compiler die Längen ausrechnen?
Da es unter Umständen größere Datenmengen werden können, möchte ich versuchen, dass es so weit wie möglich automatisiert läuft (ohne Längenanpassungen)

Wer echt der Hit, wenn mir jemand sagen könnte, ob es in Pascal/Delphi doch funktioniert!
Danke schon einmal dafür

[Meflin]

Nein, das geht auch nicht.

[SebE]

Klare Ansage!

Danke dir.

[Meflin]

Zitat von SebE:

Klare Ansage!

Ich wünschte ich irre mich. Nützlich wärs nämlich

[R2009]

Hi,

konstant und dynamisch sind doch eigentlich ein Wiederspruch in sich oder?
Erklär doch mal genauer was du erreichen willst!

Schönen Tag noch!

[Satty67]

Wieso Widerspruch, dynamisch Größe für Ableitungen, die aber mit konstanten Werten.

So sind meine Tabellen-Felder vorab gespeichert. Array mit dynamischer Anzahl Feld/Typ und dann die konstanten Arrays jeder Tabelle mit der individuellen Anzahl an Werten.

Würde der Konstrukt wie oben funktionieren, könnte ich noch Datenbank und Tabellenname mit in einem Record speichern.

[himitsu]

Du könntest höchsten die Unter-Arrays als einzelne Konstanten erstellen und müßtest diese dann in die große Konstante einbinden.

Einzehln geht nicht, da du ja eine Array-Größe in der Struktur angeben muß und dieses nicht für jede Subebene einzeln angegeben werden kann.


[add]
Möglich wäre auch noch die maximale Größe vorzugeben und den Rest aufzufüllen.
z.B. mit Nullen oder einem mich-gibt's-nicht-Wert und eventuell noch eine Längenangabe an den Anfang zu stellen.

[sirius]

*räusper*
Hätte eigentlich nicht gedacht, dass dies funktioniert

Delphi-Quellcode:

type
  rec = record
    irgendwas: CHAR;
    liste: array of integer;
    end;

const
  L1: array[0..4] of integer=(2, //erster Eintrag ist Referenzzähler 
                              3, //zweiter Eintrag für die Länge des eigentlichen Arrays
                              3, 5, 90);  //und hier der Inhalt des eigentlichen Arrays
  L2: array[0..6] of integer=(2, 5, 1, 2, 3, 5, 0); //same as L1
  A: array[0..1] of rec = (
    (irgendwas: 'a'; liste: @L1[2]),  //Zeiger auf den ersten eigetlichen Wert des Arrays
    (irgendwas: 't'; liste: @L2[2])
    );

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;


var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var i,j:Integer;
begin
  for i:=low(a) to high(a) do
  begin
    memo1.lines.add(a[i].irgendwas);
    for j:=low(a[i].liste) to high(a[i].liste) do
      memo1.lines.add(inttostr(a[i].liste[j]));
  end;
end;

Edit: Fast vermutet und hat sich beim Test bestätigt --> einen referenzzähler brauchen unsere Arrays auch. -1, wie bei constanten Strings funktioniert leider nicht, also nehme ich mal +1.
Edit2: Die Frage ist noch, wie man das simuliert, wenn man mal kein Integer-Array hat?

Edit3: Und wer es mal für andere Arrays sucht...hier mal am Beispiel Strings.
Problem ist dabei noch der Referenzzähler. Bei 1 gibt es am Ende des Projektes einen Runtime-Error. Naja...ob man das produktiv einsetzen sollte?

Delphi-Quellcode:

type
    rec = record
    irgendwas: CHAR;
    liste: array of string;
    end;

    THeader=record
      ref:Integer;
      length:Integer;
    end;

    TL1 =record
      Header:THeader;
      Content:array[0..2] of string;
    end;

    TL2 =record
      Header:THeader;
      Content:array[0..4] of string;
    end;


const
  L1: TL1=(Header:(ref: 2; length: 3);
           Content: ('A','B','C'));
  L2: TL2=(Header:(ref: 2; length: 5);
           Content: ('A','B','C','D','X'));
  A: array[0..1] of rec = (
    (irgendwas: 'a'; liste: @L1.Content),
    (irgendwas: 't'; liste: @L2.Content)
    );

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;




var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var i,j:Integer;
    test:rec;
begin
  for i:=low(a) to high(a) do
  begin
    memo1.lines.add(a[i].irgendwas);
    for j:=low(a[i].liste) to high(a[i].liste) do
      memo1.lines.add(a[i].liste[j]);
  end;

  memo1.lines.add('---');
  Test:=a[0];

  for i:=low(a) to high(a) do
  begin
    memo1.lines.add(a[i].irgendwas);
    for j:=low(a[i].liste) to high(a[i].liste) do
      memo1.lines.add(a[i].liste[j]);
  end;

  memo1.lines.add('---');
  memo1.lines.add(test.irgendwas);
  for j:=low(test.liste) to high(test.liste) do
    memo1.lines.add(test.liste[j]);
end;

[himitsu]

klar geht das ... schon seit D4 ... da mal gemacht so ähnlich gemacht hatte

Delphi-Quellcode:

const
  L1: record
    RefCount, Length: Integer;
    Data: array[0..4] of Irgendwas;
  end;

@L1.Data

[edit] ahhh, bist ja selbst schon draufgekommen

[add]
nimm aber lieber einen RefCount von mindestens 2 ... nicht das es Probleme gibt, wenn du das simulierte ConstArray mal an eine andere Array-Variable übergibst.

[sirius]

Zitat von himitsu:

klar geht das ... schon seit D4 ... da mal gemacht so ähnlich gemacht hatte

Das liegt wohl mindestens an den fehlenden dynamischen Arrays vor D4

Edit:

Zitat:

[add]
nimm aber lieber einen RefCount von mindestens 2 ... nicht das es Probleme gibt, wenn du das simulierte ConstArray mal an eine andere Array-Variable übergibst.

Habsch do!
Edit2: Oder meinst du im Integer-Array? Da gabs aber keine Probleme. Ich ändere es gleich. Besser ist.