Hi @dost0011
Array4 beinhaltet nach der Schleife die Inhalte von den anderen 3 Arrays.
Local $Array1[1000]
Local $Array2[1000]
Local $Array3[1000]
Local $Array4[1000][3]
For $i = 0 To 999 ; Wenn wirklich dieser Wert in allen Arrays gleich ist!
$Array4[$i][0] = $Array1[$i]
$Array4[$i][1] = $Array2[$i]
$Array4[$i][2] = $Array3[$i]
Next
Das klappt so nur, wenn die wirklich alle gleich groß sind. Sonst stürzt dieser plumpe Ansatz ab 
#include <Array.au3>
Local $a = [1, 2, 3, 4, 5, 6], $b = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
Local $c = [1, ConsoleWrite, Eval, 3.141], $d[100], $e = [Default, Null]
Local $f = Foo($a, $b, $c, $d, $e)
_ArrayDisplay($f)
Func Foo($a0, $a1 = 0, $a2 = 0, $a3 = 0, $a4 = 0)
Local $aU = [UBound($a0), UBound($a1), UBound($a2), UBound($a3), UBound($a4)], $iMax = $aU[0], $n = @NumParams
For $i = 1 To $n - 1 Step 1
If $iMax < $aU[$i] Then $iMax = $aU[$i]
Next
Local $aRet[$iMax][$n]
For $i = 0 To $aU[0] - 1 Step 1
$aRet[$i][0] = $a0[$i]
Next
If $n > 1 Then
For $i = 0 To $aU[1] - 1 Step 1
$aRet[$i][1] = $a1[$i]
Next
EndIf
If $n > 2 Then
For $i = 0 To $aU[2] - 1 Step 1
$aRet[$i][2] = $a2[$i]
Next
EndIf
If $n > 3 Then
For $i = 0 To $aU[3] - 1 Step 1
$aRet[$i][3] = $a3[$i]
Next
EndIf
If $n > 4 Then
For $i = 0 To $aU[4] - 1 Step 1
$aRet[$i][4] = $a4[$i]
Next
EndIf
Return $aRet
EndFuncFür beliebige Arrays. (Hab die Funktion aber nicht getestet, also am besten selbst nochmal drüberschauen)
M
Hab die Funktion aber nicht getestet
Ich aber... wie zu erwarten - sie funktioniert.
Func Foo($a, $b, $c, $d, $e)
Für wirklich große Arrays ist das so allerdings keine gute Lösung...
da wäre es angebracht den Parametern das Schlüsselwort ByRef voranzustellen.
Func Foo(ByRef $a, ByRef $b, ByRef $c, ByRef $d, ByRef $e)
Warum?
Hier ein Auszug aus der deutschen Hilfe:
Das Schlüsselwort ByRef zeigt an, dass der Parameter als Referenz zu dem Originalobjekt behandelt werden soll. Standardmäßig wird der Parameter in eine neue Variable kopiert. Jedoch verknüpft ByRef die neue Varaible auf den Originalparameter. ByRef ist zu bevorzugen wenn eine Funktion große Mengen an Daten beinhaltet, wie zum Beispiel ein großen Array. Wird dies nicht getan, so erweist das kopieren aller Daten als Bremsklotz.
Wird das Schlüsselwort ByRef angegeben, sind diese Parameter allerdings nicht mehr optional und sie müssen zudem auch als Variable übergeben werden, welche in dem Fall ja als Referenz verwendet werden.
Mit etwas Tricky kann man diesen Umstand aber umgehen und die Vorteile von ByRef nutzen, indem wir (an beliebiger Stelle) einfach Dummy-Variablen verwenden, um so die geforderte Anzahl an Parametern für unsere Funktion zu liefern.
;-- TIME_STAMP 2016-11-22 05:02:01
#include <Array.au3>
Global $a[100], $b = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
Global $c = [1, ConsoleWrite, Eval, 3.141], $d = [1, 2, 3, 4, 5, 6], $e = [Default, Null]
Global $f, $aDummy = -1, $bDummy = -1, $cDummy = -1, $dDummy = -1, $eDummy = -1
$f = DisplayFoo($a, $b, $c, $d, $e)
$f = DisplayFoo($a, $b, $c, $dDummy, $eDummy)
$f = DisplayFoo($aDummy, $b, $cDummy, $d, $eDummy)
$f = DisplayFoo($a, $bDummy, $c, $dDummy, $e)
$f = DisplayFoo($a, $b, $cDummy, $d, $eDummy)
; Hier gibt es natürlich ein Error...
$f = DisplayFoo($aDummy, $bDummy, $cDummy, $dDummy, $eDummy)
Func DisplayFoo(ByRef $a0, ByRef $a1, ByRef $a2, ByRef $a3, ByRef $a4)
$f = Foo($a0, $a1, $a2, $a3, $a4)
If @error Then ConsoleWrite("! #Error: " & $f & @LF & "!@ " & @TAB & "#Error: " & @error & @LF)
_ArrayDisplay($f)
Return $f
EndFunc
Func Foo(ByRef $a0, ByRef $a1, ByRef $a2, ByRef $a3, ByRef $a4)
Local $aU = [UBound($a0), UBound($a1), UBound($a2), UBound($a3), UBound($a4)], $iMax = $aU[0], $n = @NumParams, $col = $n
For $i = 1 To $n - 1 Step 1
If $iMax < $aU[$i] Then $iMax = $aU[$i]
If $aU[$i] = 0 Then $col -= 1
Next
If $iMax < 1 Then Return SetError(1, 0, 'Kein Array zum Kopieren gefunden...')
Local $aRet[$iMax][$col], $k = 0
For $j = 0 To UBound($aU) - 1 Step 1
Select
Case $aU[$j] > 0 And $j = 0
For $i = 0 To $aU[$j] - 1 Step 1
$aRet[$i][$k] = $a0[$i]
Next
$k += 1
Case $aU[$j] > 0 And $j = 1
For $i = 0 To $aU[$j] - 1 Step 1
$aRet[$i][$k] = $a1[$i]
Next
$k += 1
Case $aU[$j] > 0 And $j = 2
For $i = 0 To $aU[$j] - 1 Step 1
$aRet[$i][$k] = $a2[$i]
Next
$k += 1
Case $aU[$j] > 0 And $j = 3
For $i = 0 To $aU[$j] - 1 Step 1
$aRet[$i][$k] = $a3[$i]
Next
$k += 1
Case $aU[$j] > 0 And $j = 4
For $i = 0 To $aU[$j] - 1 Step 1
$aRet[$i][$k] = $a4[$i]
Next
$k += 1
EndSelect
Next
Return $aRet
EndFuncSorry, ich habe die Funktion überhaupt nicht verstanden. Das Ergebnis gefällt mir auch nicht.
Ich will mich keineswegs mit Mars messen, der sein Konstrukt ja sogar blind geschrieben hat, aber ich würde es eher so machen:
#include <Array.au3>
Local $aArray1[4] = ["1", "2", "3", "4"]
Local $aArray2[12] = ["1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4"]
Local $aArray3[36] = ["1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4", "1", "2", "3", "4"]
Local $aArray4[3][2] ; In dieses Array werden je "Zeile" ein Array in "Spalte 1" und dessen Größe in "Spalte 2" geschrieben.
$aArray4[0][0] = $aArray1
$aArray4[1][0] = $aArray2
$aArray4[2][0] = $aArray3
$aArray4[0][1] = UBound($aArray1)
$aArray4[1][1] = UBound($aArray2)
$aArray4[2][1] = UBound($aArray3)
Local $iMaxSize = _ArrayMax($aArray4, 0, -1, -1, 1) ; Mit ArrayMax wird hier der höchste Wert aus SubItem 1 geholt (der höchste Größenwert der Arrays).
Local $ArrayResult[$iMaxSize][3] ; Das Ergebnis-Array wird mit der größten Zeilenanzahl $iMaxSize und der Anzahl der Arrays deklariert.
For $i = 0 To 2 ; Für die Anzahl der Arrays..
$TempArray = $aArray4[$i][0] ; Das jeweilige Array wird in ein anderes geschrieben, weil ich nicht weiß, wie man mit Arrays in Arrays besser umgeht ;)
For $ii = 0 To $aArray4[$i][1] - 1 ; Die die Anzahl der Zeilen im jeweiligen Array..
$ArrayResult[$ii][$i] = $TempArray[$ii] ; Die jeweilige Zeile im Ergebnis-Array ($ii) in der Spalte ($i) wird mit der jeweiligen Zeile aus den Arrays gefüllt.
Next
Next
_ArrayDisplay($ArrayResult)Sorry, aber das ist keine gute Lösung, denn...
1.) ...damit kopierst du die Arrays ja zwei Mal: zuerst nach $aArray4, dann nach $ArrayResult - und ignorierst damit zu 100% was ich bezüglich "ByRef" geschrieben habe.
2.) ...sie ist nicht als Funktion mit variabler Anzahl an Parametern ausgelegt.
Das Ergebnis gefällt mir auch nicht.
Das Ergebnis ist ja auch speziell auf die Anfrage von @dost0011 ausgerichtet.
Stimmt. 
