2DArray in der Parameterübergabe erstellen??

[DrTosh]

Guten Tag,
ich frage mich ob ich ein 2DArray direkt in die Parameterübergabe eintragen kann.

Beispiel

Code:

type 
  T2DControls = Array of Array of TControl;

procedure pDo1D(lCs: Array of TControl); // das habe ich
procedure pDo2D(lCs: T2DControls); // das möchte ich

procedure Click;
begin
  pDo1D([lControl1, lControl2, lControl3, ...]); // Das geht
  pDo2D(/*genau hier weiß ich nicht wie es geht */);  
end;

folgendes habe ich probiert:
pDo2D([[lControl1, lControl2, lControl3, ...], [lControl1, lControl2, lControl3, ...]]);
pDo2D(([lControl1, lControl2, lControl3, ...], [lControl1, lControl2, lControl3, ...]));
pDo2D([(lControl1, lControl2, lControl3, ...), (lControl1, lControl2, lControl3, ...)]);


kann mir da jemand helfen?

[Neutral General]

Hallo,

Was (bei neueren Delphi Versionen) funktionieren könnte wäre:

Delphi-Quellcode:

type 
  T1DControls = Array of TControl;
  T2DControls = Array of Array of TControl;

procedure pDo2D(lCs: T2DControls); // das möchte ich

procedure Click;
begin
  pDo2D(T2DControls.Create(T1DControls.Create(a,b,c), T1DControls.Create(d,e,f,g,h))); 
end;

[uligerhardt]

Zitat von DrTosh:

Code:

type 
  T2DControls = Array of Array of TControl;

procedure pDo1D(lCs: Array of TControl); // das habe ich
procedure pDo2D(lCs: T2DControls); // das möchte ich

Du hast da zwei grundverschiedene Array-Typen: pDo1D nimmt ein offenes Array entgegen, pDo2D hingegen ein dynamisches Array (von dynamischen Arrays). Und für dynamische Arrays funktioniert die Syntax mit [...] nicht.

Siehe hier: http://www.rvelthuis.de/articles/articles-openarr.html

[SMO]

Mist, ich war zu langsam... aber egal.


Delphi hat quasi drei verschiedene Array-Typen, deren Details sich voneinander unterscheiden, und die nicht direkt Zuweisungskompatibel sind.

1. Statische Arrays:
   Test: array [0..9] of Integer;
   Test2: array [0..15, 0..31] of Byte;
   usw.
   Das sind einfach nur zusammenhängende Speicherblöcke entsprechender Größe.
2. Dynamische Arrays:
   Test: array of Integer;
   Test2: TIntegerDynArray; // alter Typ bevor es Generics gab
   Test3: TArray<Integer>; // neuer Typ nach Generics
   Das sind Zeiger (Pointer) auf dynamisch allozierten Heap-Speicher.
   Mehrdimensionale DynArrays (z.B. "Test3: array of array of Integer") sind deshalb keine zusammenhängende Speicherblöcke, sondern Zeigerlisten (array of Pointer), die auf weitere Zeigerlisten verweisen, bis man in der letzten Dimension angekommen ist.
3. Offene Array-Parameter:
   Kommen als Funktions/Prozedurparameter zum Einsatz, wenn man solche Deklarationen vornimmt:
   procedure MachWas(Werte: array of Integer);
   function function Format(const Format: string; const Args: array of const): string;

Dein erstes Beispiel, "pDo1D", benutzt also einen offenen Array-Parameter.
Das zweite, "pDo2D", dagegen ein dynamisches Array.

Neuere Delphi-Versionen (ab XE8?) haben erweiterte Syntax für dynamische Arrays bekommen, so dass z.B. das hier möglich ist:
Test := [1, 2, 3, 4];
Damit könnte vielleicht auch ein Funktionsaufruf mit der Syntax offener Array-Parameter funktionieren.

Sonst musst du so vorgehen:

Delphi-Quellcode:

type
  T2DControls = Array of Array of TControl;

procedure pDo2D(lCs: T2DControls);

procedure Click;
var
  C: T2DControls;
begin
  SetLength(C, 2, 4);  // Dimension des Arrays = 4 Spalten, 2 Zeilen
  C[0, 0] := lControl1;
  C[0, 1] := lControl2;
  C[0, 2] := lControl3;
  C[0, 3] := lControl4;
  C[1, 0] := lControl5;
  C[1, 1] := lControl6;
  C[1, 2] := lControl7;
  C[1, 3] := lControl8;
  C[2, 0] := lControl9;
  // usw.
  pDo2D(C);
end;

Oder warum nimmst du nicht einfach ein (offenes) eindimensionales Array und "simulierst" die zweite Dimension (genauso funktionieren mehrdimensionale statische Arrays):

ElementXY := MyArray1D[Y * Breite + X];
Wobei X von 0 bis Breite-1 läuft, und Y von 0 bis Höhe-1.

[Dejan Vu]

Ich weiß ja nicht, ob das alles so schön lesbar ist. Und darauf kommt es doch an, oder?

Vielleicht deklarierst Du dir einfach zwei Variablen (mit aussagekräftigem Namen) vom Typ 2DArray und initialisierst diese analog zu den schon gezeigten Verfahren. Im Click-Ereignis übergibst Du dann diese Variablen. Das ist lesbar und jeder weiß, was gemeint ist.

[HolgerX]

Oder eine Kombination:

Delphi-Quellcode:

type
  T1DControls = Array of TControl;
  T2DControls = Array of T1DControls;

procedure Set1d(var A1D : T1DControls ; C : Array of TControl);
var
  i : integer;
begin
  setlength(A1D,length(c));
  for i := 0 to length(c) do A1D[i] := c[1];
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  tmp2D : T2DControls;
begin
  setlength(tmp2D,2);
  Set1d(tmp2d[0],[Button1,Button2,Button3]);
  Set1d(tmp2d[1],[Button4,Button5,Button6]);

  ShowMessage(tmp2d[1][2].Name);

end;