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;

[Back2Code]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1229969)

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;

Kann man nicht einfach SetLength(100, 100); machen? Kann jetzt grad nicht folgen, warum du ingesamt 3 x die Länge änderst.

[Jonas Shinaniganz]

Zitat:

Kann man nicht einfach SetLength(100, 100); machen? Kann jetzt grad nicht folgen, warum du ingesamt 3 x die Länge änderst.

Mit einem einzigen Aufruf von SetLength kannst du nicht das erreichen, was ich in dem Quellcode gemacht habe.

SetLength(myArray,100, 100) würde dir ein Mehrdimensionales Array erzeugen, bei dem die erste Dimension 100 Elemente lang ist und jedes dieser Elemente in der zweiten Dimension erneut 100 Elemente lang ist.

Bei meinem kurzen Beispiel sind die einzelnen Elemente der ersten Dimension von unterschiedlicher Länge, wenn man sie 2-Dimensional betrachtet.

[Back2Code]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1229972)

Zitat:

Kann man nicht einfach SetLength(100, 100); machen? Kann jetzt grad nicht folgen, warum du ingesamt 3 x die Länge änderst.

Mit einem einzigen Aufruf von SetLength kannst du nicht das erreichen, was ich in dem Quellcode gemacht habe.

SetLength(myArray,100, 100) würde dir ein Mehrdimensionales Array erzeugen, bei dem die erste Dimension 100 Elemente lang ist und jedes dieser Elemente in der zweiten Dimension erneut 100 Elemente lang ist.

Bei meinem kurzen Beispiel sind die einzelnen Elemente der ersten Dimension von unterschiedlicher Länge, wenn man sie 2-Dimensional betrachtet.

Also wenn ich vorhabe mein zweidimensionales Array in der 1 Dimension in Länge 100 zu ändern und die 2te in 60 ist das hier folglich falsch?

Delphi-Quellcode:

  SetLength(UniversumsMatrix, 100, 60);

Und so wärs richtig?

Delphi-Quellcode:

  SetLength(UniversumsMatrix,100);

  SetLength(UniversumsMatrix[0],60);

[Jumpy]

Du hast glaub ich noch nicht verstanden, das die zweite Dimension für jedes "Array aus der ersten Dimension" unterschiedlich groß sein kann.

Delphi-Quellcode:

SetLength(UniversumsMatrix, 100, 60);

//entspricht

SetLength(UniversumsMatrix,100);
for i:=High(UniversumsMatrix) to Low(UniversumsMatrix) do
  SetLength(UniversumsMatrix[i],60);

[Blup]

Obwohl eigentlich schon alles gesagt wurde, versuche ich es noch einmal anders zu erklären.
Genau genommen verwaltet Delphi keine dynamischen mehrdimensionalen Arrays, bei denen alle Elemente in einem Speicherbereich liegen.

Im Speicher sieht das dann im Prinzip so aus (-> zeigt auf Speicher):

Code:

UniversumsMatrix(Pointer) -> array(UniversumsMatrix0(Pointer), UniversumsMatrix1(Pointer), ..., UniversumsMatrix99(Pointer))

UniversumsMatrix0(Pointer) -> array(UniversumsMatrix0_0(Boolean), UniversumsMatrix0_1(Boolean), ..., UniversumsMatrix0_59(Boolean))
UniversumsMatrix1(Pointer) -> array(UniversumsMatrix1_0(Boolean), UniversumsMatrix1_1(Boolean), ..., UniversumsMatrix1_59(Boolean))
...
UniversumsMatrix99(Pointer) -> array(UniversumsMatrix99_0(Boolean), UniversumsMatrix99_1(Boolean), ..., UniversumsMatrix99_59(Boolean))

Jedes Array-Element der ersten Dimension verweist auf ein eigenes unabhängiges Array der zweiten Dimension.
Jedes Array der zweiten Dimension kann gleich groß sein, muss aber nicht.

Ein anderes Beispiel:

Delphi-Quellcode:

  SetLength(UniversumsMatrix, 100, 60);
  SetLength(UniversumsMatrix, 101);
  SetLength(UniversumsMatrix[101], 5);

In der ersten Dimension sind jetzt 101 Arrays enthalten.
Die Arrays UniversumsMatrix[0] .. UniversumsMatrix[99] enthalten jeweils 60 Elemente, UniversumsMatrix[100] aber nur 5.

Zitat:

Zitat von Back2Code (Beitrag 1229957)

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:

Deshalb ist deine ursprüngliche Frage für die 2.Dimension nicht eindeutig zu beantworten.
Man kann die Größe eines konkreten Elements der ersten Dimension bestimmen z.B. UniversumsMatrix[0].
Wurde vorher beim Erstellen des Arrays dafür gesorgt das alle anderen Elemente genauso groß sind, weis man Bescheid.
Ansonsten muss die Größe für jedes Element UniversumsMatrix[0] .. UniversumsMatrix[100] einzeln bestimmt werden.

[Jonas Shinaniganz]

ha achso :)... nein ein 2-Dimensionales Array sind nicht einfach 2 1D-Arrays nebeneinander!

Schau dir am besten mal auf z.b. Youtube was Grundsätzliches an:


In dieser Video-Reihe werden sogar 10 Dimensionen erklärt :)

http://www.youtube.com/watch?v=4s1-UR3D21s

gruß!

[sx2008]

Also wenn man ein rechteckiges (2-dimensionales) Bit-Array braucht dann würde ich die Klasse TBits nehmen und davon ableiten.
TBits ist ja im Prinzip eine eindimensionale Liste von Booleans die dicht gepackt verwaltet werden.
Insbesondere bei grossen Arrays ist TBits sehr platzsparend.
Man kann ja die 2-dimensionalen Indexe sehr leicht auf einen 1-dimensionalen Index umrechnen.