Jag har en multidimensionell array som jag vill kunna skicka med till en function. Är det möjligt att göra det och i så fall hur?

Det går iofs att komma runt problemet med att göra denna array global, men jag behöver denna function som jag ska kunna använda var som helst och då måste jag kunna skicka med mina arrays till min function när jag anropar den.

Det är ingen bra lösning,överhuvudtaget skall man undvika multidimmensionella arrayer.Kolla om du inte kan göra den endimmensionell , tex på fack 100
börjar dimmension 2. Eller ändå bättre gör tex 4 endimensionella istället.Om du behöver det

Gör arrayen Global i den Form den verkar.

Har aldrig skickat 2 dimmensionel, 1 dimmensionell går bra , orkar inte just nu
det finns flera krafter där ute.

Någon annan som vet hur man gör detta (om möjligt)?

Vad är det för array? GVilken version av VB använder du?

I vb 5 an du bar skicka variantarrayer:
<code>
Sub Test
Dim Test As Variant
Redim Test(1 to 10, 1 to 10)
End Sub

Function DoStuff(Data As Variant)

End Function
</code>
I vb 6 kan du skicka deklarerade arrayer:
<code>
Sub Test
Dim Test() As String
Redim Test(1 to 10, 1 to 10)
End Sub

Function DoStuff(Data() As String)

End Function
</code>
Kan även retunera array:
<code>
Function GetArray() As String()
Dim Result() As String
Redim Result(1 to 10, 1 to 10)
GetArray = Result
End Function

Sub Test
Dim Test() As String
Test = GetArray
End Sub
</code>

Om man inte specificerar storleken för dimensionerna i anropet, hur tusan får man fram hur många det är?
Typsäkerheten går ju åt skogen!

LBound() och UBound() funktionen. Eller vad menar du?

Nej, om du skickar en array av typen (1 to 10) eller en (1 to 10, 1 to 10), hur vet VB hur många dimensioner den har och hur använder man dimensionerna?

Låt säga att jag har en

Public Sub Ba()
Dim k() As Long
ReDim k(1 To 10, 1 To 10) As Long

Bu k
End Sub

Public Sub Bu (A() As Long)

'Hur fan använder man A här?

End Sub

MAn kan testa om UBound/LBound ger fel:

T,Ex.
<code>

Public Sub Test()
Dim Data
ReDim Data(1 To 3)
Data(1) = "A"
Data(2) = "B"
Data(3) = "C"

ListData Data

ReDim Data(1 To 3, 1 To 3)
Data(1, 1) = "A:A"
Data(1, 2) = "A:B"
Data(1, 3) = "A:C"
Data(2, 1) = "B:A"
Data(2, 2) = "B:B"
Data(2, 3) = "B:C"
Data(3, 1) = "C:A"
Data(3, 2) = "C:B"
Data(3, 3) = "C:C"

ListData Data

End Sub

Function ListData(Data)
Dim x As Long
Dim y As Long
Select Case ArrayDimensions(Data)
Case 1
For x = LBound(Data) To UBound(Data)
Debug.Print Data(x)
Next
Case 2
For x = LBound(Data, 1) To UBound(Data, 1)
For y = LBound(Data, 1) To UBound(Data, 1)
Debug.Print Data(x, y), ;
Next
Debug.Print
Next
End Select

End Function

Function ArrayDimensions(Data) As Long
Dim x As Long
On Error GoTo Done
x = LBound(Data, 1)
ArrayDimensions = 1

x = LBound(Data, 2)
ArrayDimensions = 2

x = LBound(Data, 3)
ArrayDimensions = 3

x = LBound(Data, 4)
ArrayDimensions = 4

x = LBound(Data, 5)
ArrayDimensions = 5

'Overflow
x = LBound(Data, 6)
ArrayDimensions = -1

Done:

End Function

</code>

Rysligt, men ok...

Det måste vara en av de värsta "typsäkerhetskrångligheterna" som finns. Och så ineffektivt VB måste sköta problemet, dels en förbannat massa overhead, dels nästan fullständigt omöjligt att optimera...

Hur löser man det i andra språk? Varför ha arrayer med olika antal dimensioner. att skicka det som argument tycker jag är fel.

I C löser man det till exempel så här:

int funktion(int arg[][20], int n)

eller

int funktion(int **arg, int n, int m)

I C++ kunde man t.ex. använt en vector<vector<int> >

Observera att i första fallet så blir det både effektivt och lättskrivet, eftersom kompilatorn vet exakt hur den ska hantera arrayen. I det sista fallet blir det inte fullt lika effektivt.

>Varför ha arrayer med olika antal dimensioner. att skicka det som argument tycker jag är fel.
Ja, det gör jag med, men det går ju tydligen i VB, och därför så missar man ju typsäkerheten. I C-fallen ovan vet kompilatorn exakt hur det skall fungera, och i C++-fallet ligger ansvaret på den som skrivit vector, så kompilatorn behöver inte se till att det finns någon run-time-information.

Du kunde börja med Collection-classes istället så slipper du allt det här mecket med att kolla typer. Kolla i MSDN efter det. Eller på nätet.

/Egget