Zweidimensionales Array of Boolean Verständnisfrage

[Back2Code]

Wie man mit Low / High auf das jeweils niedrigste / höchste Element eines eindimensionalen Arrays zugreift ist mir bewusst.

Delphi-Quellcode:

Low(Array) / High(Array)

Was ich grade aber nicht verstehe bzw. nicht darauf komme ist, wie ich auf den niedrigsten / höchsten Wert von einem zweidimensionalen Array komme.

Delphi-Quellcode:

TTwoDimensionalArray = array of array of Boolean;

Also was ich gerne machen möchte, ist folgendes:

Delphi-Quellcode:

  //Als Integer deklariert um den jeweils niedrigsten/höchsten Wert des 2 Dimensionalen Arrays zu speichern
  MinArray1 := Low(UniversumsMatrix); // 1 Dimension
  MaxArray1 := High(UniversumsMatrix); // 1 Dimension
  MinArray2 := Low(UniversumsMatrix); // 2 Dimension
  MaxArray2 := High(UniversumsMatrix); // 2 Dimension

Das Problem was hierbei ensteht ist soweit ich das beurteilen kann nur jeweils die Low/High Werte vom ersten Array genommen werden und Min/MaxArray2 genau die gleiche Länge haben wird wie MinMaxArray1.

Was ich also eigentlich wissen möchte, ist wie ich auf den niedrigsten/höchsten Wert eines zweidimensionalen Arrays komme und zwar beide Dimensionen. :cry:

[Mikkey]

Mach es auf die Art:

Delphi-Quellcode:

  //Als Integer deklariert um den jeweils niedrigsten/höchsten Wert des 2 Dimensionalen Arrays zu speichern
  MinArray1 := Low(UniversumsMatrix); // 1 Dimension
  MaxArray1 := High(UniversumsMatrix); // 1 Dimension
  MinArray2 := Low(UniversumsMatrix[0]); // 2 Dimension
  MaxArray2 := High(UniversumsMatrix[0]); // 2 Dimension

Es muss natürlich sicher sein, dass die erste Dimension mindestens eins lang ist.

[Jumpy]

Ist die zweite Dimension nicht von der Position im ersten Array abhängig?

MinArray2_0 := Low(UniversumsMatrix[0]);
MinArray2_1 := Low(UniversumsMatrix[1]);
usw.

[Back2Code]

Zitat:

Zitat von Mikkey (Beitrag 1229959)

Mach es auf die Art:

Delphi-Quellcode:

  //Als Integer deklariert um den jeweils niedrigsten/höchsten Wert des 2 Dimensionalen Arrays zu speichern
  MinArray1 := Low(UniversumsMatrix); // 1 Dimension
  MaxArray1 := High(UniversumsMatrix); // 1 Dimension
  MinArray2 := Low(UniversumsMatrix[0]); // 2 Dimension
  MaxArray2 := High(UniversumsMatrix[0]); // 2 Dimension

Es muss natürlich sicher sein, dass die erste Dimension mindestens eins lang ist.

Das stelle ich beim Starten sicher mit:

Delphi-Quellcode:

  SetLength(UniversumsMatrix, 200, 200);

[Neutral General]

Naja ein Zweidimensionales Array ist quasi eine Liste von 1-dimensionalen Arrays.

Mit High(ZweiD) bekommst du die Anzahl der Zeilen und mit High(ZweiD[n]) bekommst du die Anzahl der Spalten der n-ten Zeile (Wobei die theoretisch pro Zeile unterschiedlich sein kann).

[Jonas Shinaniganz]

Mehrdimensionale Arrays in Delphi können in sich unterschiedlich lang sein!

Wenn du nicht genau weißt, wie lang die Dimensionen vorher sind musst du z.b. beim durchlaufen darauf achten.

1 Beispiel:

[a][b][c][d][e] - Eindimensionales Array

2 Beispiel:

[a][b][c][d][e] - Mehrdimensionales Array
[a][b][c][d][e]
[a][b][c][d][e]
[a][b][c][d][e]
[a][b][c][d][e]

3 Beispiel:

[a][b][c][d][e] - Mehrdimensionales Array
[a][b][c]....[e]
[a]....[c]
[a]....[c]
[a]....

Deswegen musst du für jede Dimension immer prüfen wie lang diese denn jetzt ist:

High(MyArray[0]) gibt auf das 3te Beispiel eine 4. High(MyArray[1]) gibt auf das 3te Beispiel nur eine 1. High gibt dir das höchste adressierbare Element zurück. High(MyArray) gibt dir auch eine 4 zurück, jedoch ist diese 4 die Länge der ersten Dimension und nicht die Länge der ersten Folge, der zweiten Dimension (wie High(MyArray[0])).

schöne Grüße

Edit:

Zitat:

Low(Array) / High(Array) Was ich grade aber nicht verstehe bzw. nicht darauf komme ist, wie ich auf den niedrigsten / höchsten Wert von einem zweidimensionalen Array komme.

Sogesehen musst du dich erstmal fragen, was dein niedrigsten / höchsten Wert denn ist. Ich glaube du möchtest das erste Element der ersten Dimension und das letzte Element der letzten Dimension anfragen. Das gelingt dir mit:

Delphi-Quellcode:

//"höchstes" Element:

Array[High(Array),High(Array[High(Array)])]

//"niedrigstes Element" (trivial)

Array[0,0]

[Neutral General]

@Jonas: Natürlich hast du generell recht, aber wenn er weiß dass jedes Array in dem 2D-Array gleich lang ist (und so sieht es aus nachdem er uns seinen Code zum setzen der Länge des 2D-Arrays gepostet hat) dann reicht es zu prüfen ob die Länge des 2D-Arrays > 0 ist und dann kann man für die Spaltenanzahl einfach High(Array[0]) nehmen

[Jonas Shinaniganz]

@General

Das stimmt natürlich, mit gleichlangen Dimensionen arbeitet es sich ja auch wesentlich angenehmer.

[Back2Code]

Zitat:

Zitat von Neutral General (Beitrag 1229966)

@Jonas: Natürlich hast du generell recht, aber wenn er weiß dass jedes Array in dem 2D-Array gleich lang ist (und so sieht es aus nachdem er uns seinen Code zum setzen der Länge des 2D-Arrays gepostet hat) dann reicht es zu prüfen ob die Länge des 2D-Arrays > 0 ist und dann kann man für die Spaltenanzahl einfach High(Array[0]) nehmen

Was wäre denn jetzt wenn das Array1 200 lang ist und Array2 400. Wie müsste ich dann genau verfahren?

[Jonas Shinaniganz]

Du möchtest wissen, wie du korrekt durch ein mehrdimensionales Array iterierst, bei dem in der 2ten-Dimension myArray[0] unterschiedlich lang zu myArray[1] ist. In einer verschachtelten For-Schleife?

Edit

Das ginge dann so:

Delphi-Quellcode:

var
  I,I2: Integer;
  myArray : Array of Array of Boolean;
begin
  SetLength(myArray,2);

  SetLength(myArray[0],5);
  SetLength(myArray[1],10);

  for I := 0 to High(myArray) do
  begin
    for I2 := 0 to High(myArray[I]) do
    begin
      ShowMessage('[' + IntToStr(I) + '][' + IntToStr(I2) + '] ist: ' + BoolToStr(myArray[I][I2]));
    end;
  end;
end;