Hallo!

ich hab mehrere dreidimensionale arrays (Konstanten):
array[0..a] of array[0..b] of array[0..c] of Double
jedoch ist a, b und c nicht immer gleich.

Und ich hätte gerne einen array of pointer, mit dem ich auf die einzelnen dreidimensionalen arrays zeigen kann.

Ich hab aber keine ahnung ob und wie das geht, denn ich muss dann die einzelnen Daten aus den arrays auslesen können und die jeweilige größe.

Weiß jemand, wie das geht?

Danke schonmal im Voraus!

Gruß
Simon

Hi,

vielleicht so:

markieren

Delphi-Quellcode:

T3DDoubleArray = Array[0..a] of Array[0..b] of Array[0..c] of Double; // wobei mir das mit dem a,b,c bisschen seltsam vorkommt...

P3DDoubleArray = ^T3DDoubleArray;

TP3DDoubleArray = Array of P3DDoubleArray;

? Oder hab ich dich falsch verstanden?

Gruß
Neutral General

Hallo Simon,

du kannst die Funktionen High(), Low() und Length() auf einen Vektor anwenden:

zusammenfalten · markieren

Delphi-Quellcode:

const
  MAX_A = 3;
  MAX_B = 4;
  MAX_C = 5;
type
  TMatrix = array [0..MAX_A] of array [0..MAX_B] of array [0..MAX_C] of Double;
var
  m: TMatrix;
  aHigh, bHigh, cHigh: Integer;
begin
  aHigh := High(m);
  bHigh := High(m[0]);
  cHigh := High(m[0, 0]);
end;

Da du jeden Wert über seine Koordinaten in der Matrix direkt ansprechen kannst, wüsste ich nicht wofür du die Pointer brauchen könntest.

Grüße vom marabu

Hier ist ein konkretes Beispiel (ohne a,b und c):
ich hab die drei arrays

array1: array[0..19] of array[0..3] of array[0..2] of Double = (((...)));
array2: array[0..5] of array[0..2] of array[0..2] of Double = (((...)));
array3: array[0..20] of array[0..2] of array[0..2] of Double = (((...)));

und jetzt würde ich gerne alle arrays "zusammenlegen" in einerm array of pointer:

alle: array[0..2] of pointer = (array1, array2, array3);

Am schluss würde ich dann gerne die einzelnen werte auslesen können, zb:
if p[1][3][1][2] = 5.3 then ...
und ich würde gerne die dimensionen auslesen können, zb:
Length(p[2])
oder
Length(p[2][0])

wobei die fetten zeilen net funtionieren.

Was funktioniert ist
alle: array[0..2] of pointer = (@array1, @array2, @array3);
Wobei ich dann irgendwie nimmer weiß, wie ich auf die arrays zugreife...

exakt so wie du es beschrieben hast, sollte es keine Möglichkeit geben.

Wie würdet ihr das dann machen?

Ich hab solche arrays

array1: array[0..19] of array[0..3] of array[0..2] of Double = (((...)));
array2: array[0..5] of array[0..2] of array[0..2] of Double = (((...)));
array3: array[0..20] of array[0..2] of array[0..2] of Double = (((...)));

und arbeite die so ab:

zusammenfalten · markieren

Delphi-Quellcode:

for i := 0 to Pred(Length(array1)) do begin
   for j := 0 to Pred(Length(array1[0])) do begin
      Koordinate(array1[i][j][0], array1[i][j][1], array1[i][j][2]);
   end;
end;

for i := 0 to Pred(Length(array2)) do begin
   for j := 0 to Pred(Length(array2[0])) do begin
      Koordinate(array2[i][j][0], array2[i][j][1], array2[i][j][2]);
   end;
end;

for i := 0 to Pred(Length(array3)) do begin
   for j := 0 to Pred(Length(array3[0])) do begin
      Koordinate(array3[i][j][0], array3[i][j][1], array3[i][j][2]);
   end;
end;

und da es insgesamt mehr als nur 3 arrays sind würde ich die gerne alle auf einmal abarbeiten. In etw so:

markieren

Delphi-Quellcode:

for i := 0 to 2 do begin
   for j := 0 to Pred(Length(alles[i])) do begin
      for k := 0 to Pred(Length(alles[i][j])) do begin
         Koordinate(alles[i][j][k][0], alles[i][j][k][1], alles[i][j][k][2]);
      end;
   end;
end;

Oder wenn ich aus diesen arrays
array1: array[0..19] of array[0..3] of array[0..2] of Double = (((...)));
array2: array[0..5] of array[0..2] of array[0..2] of Double = (((...)));
array3: array[0..20] of array[0..2] of array[0..2] of Double = (((...)));
diese hier mache
array1: array[0..57] of array[0..2] of Double = ((...));
array2: array[0..10] of array[0..2] of Double = ((...));
array3: array[0..40] of array[0..2] of Double = ((...));
Also, dass ich ein 2-dimensionales array draus mache und nur noch die 1. Dimension unterschiedlich ist, die zweite nicht.
geht es dann?

ich würde anstelle von Arrays einfach klassen nehmen oder dynamische Arrays.
Nutze nächste mal bitte die Edit-Funktion.

aber dann kann ich die Konstanten nicht mehr so einfach reinschreiben, oder?

a: array[0..2] of array[0..2] = ((1,2,3),(4,5,6),(7,8,9))

Zitat von blablab:

aber dann kann ich die Konstanten nicht mehr so einfach reinschreiben, oder?

a: array[0..2] of array[0..2] = ((1,2,3),(4,5,6),(7,8,9))

richtig!