Wie ermittelt man die Grenzen mehrdimensionaler Arrays?

[Popov]

Mit Low und High kann man die Grenzen von Arrys ermitteln. Beim Code

Delphi-Quellcode:

var
  a: array[1..100] of Byte;
  i: Integer;
begin
  i := High(a);

erhalte ich bei i 100 als obere Grenze. Soweit alles klar. Nur wie, bzw. überhaupt, kriegt man bei mehrdimensionaler Arrays die Info für die weitere Dimension?

Delphi-Quellcode:

var
  a: array[1..100, 10..10000] of Byte;
  i: Integer;
begin
  i := High(a);

Hier erhalte ich nur den oberen Wert der ersten Dimension, also 100, ich brauche aber den zweiten Wert.

[Bernhard Geyer]

Wie wäre es damit?

Delphi-Quellcode:

  j := High(a[0]);

[Popov]

Also High(a[0]) funktioniert bei mir nicht (D3 und D7), aber High(a[1]) gibt die Grenze der zweiten Dimension. Allerdings gibt auch High(a[20]) die Grenze der zweiten Dimension.

Gibt es da eine Logik oder funktioniert es zufällig? Denn

Delphi-Quellcode:

var
  a: array[1..100, 10..10000, 0..10] of Byte;
  i: Integer;
begin
  i := High(a[2]);

gibt nicht die dritte Dimension zurück, sondern immer noch der zweiten.

[himitsu]

vielleicht fällt es so besser auf:

Delphi-Quellcode:

i := High(a[Low(a)]);  // Obergrenze des Unterarray vom 1. Array der obersten Ebene
i :=  Low(a[Low(a)]);  // Untergrenze des Unterarray vom 1. Array der obersten Ebene

Delphi-Quellcode:

var a: array[1..100, 10..10000] of Byte; 
i := High(a[Low(a)]);
i := High(a[1]);    // oder direkt
i := High(a[99]);   // 1..100 ... was ist egal, da alle Unterarrays gleich groß sind

var a: array[1..100, 10..10000, 0..10] of Byte; 
i := High(a[Low(a), Low(a[Low(a)])]);
i := High(a[Low(a)][Low(a[Low(a)])]);
i := High(a[1][10]);     // oder direkt
i := High(a[1, 10]);
i := High(a[99][9999]);  // 1..100 > 10..10000 ... was ist hier ebenfalls egal
i := High(a[99, 9999]);

[Hawkeye219]

Hallo,

vielleicht wird es auch klarer, wenn man die Array-Deklaration so schreibt:

Delphi-Quellcode:

var
  a: array [1..100] of array [10..10000] of array [0..10] of Byte;

Gruß Hawkeye

[DeddyH]

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a: array[1..100, 10..10000, 0..10] of Byte;
begin
  ShowMessage(Format('[%d..%d,%d..%d,%d..%d]',[Low(a),
                                               High(a),
                                               Low(a[Low(a)]),
                                               High(a[Low(a)]),
                                               Low(a[Low(a),Low(a[Low(a)])]),
                                               High(a[Low(a),Low(a[Low(a)])])]));
end;

Je mehr Dimensionen, desto komplizierter. Aber vielleicht hab ich auch nur ein Brett vor dem Kopf und es geht auch einfacher.

[edit] :oops: in der Art hatte das himitsu ja bereits gepostet [/edit]

[taaktaak]

Oder anders ausgedrückt:
Es wird immer die Obergrenze des nächstfolgenden Sub-Arrays ermittelt.

Delphi-Quellcode:

var a : Array [1..10,1..100,1..1000] of integer;

procedure TfoTest19.FormShow(Sender:TObject);
begin
  listbox1.Items.add(inttostr(high(a)     ));
  listbox1.Items.add(inttostr(high(a[1])  ));
  listbox1.Items.add(inttostr(high(a[1,1])));
end;

[Popov]

Ok, alles klar, hab es jetzt verstanden.

Danke an alle :thumb:

[mr_emre_d]

Eine brutale Möglichkeit, die Größe(n) eines dynamisch mehrdimensionalen Arrays zu messen, wäre folgender:

Delphi-Quellcode:

function CntArrDimensions( const Arr: Pointer ): String;
begin
  try
    Result := '0..' + IntToStr( pCardinal( Cardinal(Arr^) - 4 )^ - 1 ) + ' ' + CntArrDimensions( Pointer( Cardinal(Arr^) ) );
  except
  end;
end;

// Testaufruf
var
  Test: Array of Array of Array of Byte;
begin
  SetLength( Test, 10, 20, 30 );
  ShowMessage( CntArrDimensions( @Test ) );

MfG

[Mithrandir]

Ay Caramba.. :shock:

Aber was soll denn der überflüssige Try..Except - Block da drin? :gruebel: