Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

7.7. Meerdimensionale Arrays

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

7.7.1. Meerdimensionale Arrays

Array kennen we ondertussen als zijnde een verzameling van elementen van hetzelfde datatype.  Waarvan we de elementen kunnen benaderen via hun index.

Dergelijke arrays kunnen we dus beschouwen als een reeks, een rij of een vector van elementen, waarbij de elementen na elkaar zitten bewaard.  Je kunt hier dus spreken over één dimensional arrays.

Maar ook arrays met meerdere dimensies bestaan.

Bij de declaratie van een arrayvariabele (en het aanmaken van een array) gaat men als volgt te werk :
Dim <identifier>(<first-upperbound>, <second-upperbound> [, ...]) [<type-specifier>]
De "dimensielijst" werd tot nu toe opgevuld met 1 Integer expressie om aan te geven wat de "upperbound" (hoogste index) was binnen de array.

Bij meer dimensionale arrays geeft men dan niet alleen de upperbound van de eerste dimensie aan, maar ook van de volgende dimensies.  De verschillende upperbounds (voor iedere dimensie) worden afgescheiden in de dimensielijst door een komma (,).

Neem nu onderstaand voorbeeld, daar wordt een array aangemaakt met 2 dimensies.  Men verwijst meestal met de term "rij" ("row") naar de eerste dimensie en met de term "kolom" ("column") naar de tweede dimensie.  Dus je zou in onderstaand voorbeeld kunnen spreken over een array met 2 rijen en 3 kolommen :
Visual Basic 2012 Broncode - Codevoorbeeld 125
Module Example1
    Sub Main()
        Dim rowCount As Integer = 2
        Dim columnCount As Integer = 3
        '
        Dim upperboundFirstDimension As Integer = rowCount - 1
        Dim upperboundSecondDimension As Integer = columnCount - 1
        '
        Dim matrix(upperboundFirstDimension, _
                   upperboundSecondDimension) As Integer
        '
        matrix(0, 0) = 10
        matrix(1, 0) = 20
        matrix(1, 2) = 30
        '
        Console.WriteLine("first row, first column   : " & matrix(0, 0))
        Console.WriteLine("second row, first column  : " & matrix(1, 0))
        Console.WriteLine("second row, second column : " & matrix(1, 1))  ' (1)
        Console.WriteLine("third row, third column   : " & matrix(1, 2))
        '
        Console.ReadLine()
    End Sub
End Module
Console Application Output
first row, first column   : 10
second row, first column  : 20
second row, second column : 0
third row, third column   : 30
Naar een element in de array kunnen we verwijzen door na de identifier van die array tussen de haakjes te verwijzen naar de index(en) van het element.
Ook bij meerdimensionale arrays gaat men op dezelfde wijze te werk.  Het verschil is echter wel dat men nu naar meerdere indexen dient te verwijzen, de verschillende indexwaarden worden afgescheiden door een komma (,).

Een twee dimensionale tabel wordt ook wel eens "matrix" genoemd, vandaar de identifier matrix.

Ook bij meer dimensionale arrays blijft het zo dat dit verzamelingen zijn van elementen van hetzelfde datatype, en wel dat datatype dat vermeldt werd in de As clausule van de declaratie van die arrayvariabele.

Aan de output veroorzaakt door regel (1) merk je dat ook na declaratie van een meer dimensionale tabel alle elementen de defaultwaarde van het datatype van de elementen van de array bevatten.  Hier dus elementen van het datatype Integer dat nul als defaultwaarde heeft.

We zouden de tabel (matrix)  hier als volgt kunnen voorstellen :
            column-index  0       1       2
row-index
        0                 10      0       0
        1                 20      0       30
Dit is dus de voorstelling die men doorgaans zou maken voor een twee dimensionale array.  Men spreekt dus doorgaans over de elementen van de eerste dimensie als zijnde de rijen, en over de elementen van de tweede dimensie als zijnde de kolommen.

Dit is echter maar een fictieve visuele representatie, het blijft zo dat in het geheugen alle elementen naast elkaar zitten bewaard (en dit oplopend per laatste dimensie).  Je zou het dus ook zo kunnen voorstellen :
   row-index :  0      0       0       1       1       1
column-index :  0      1       2       0       1       2
      values :  10     0       0       20      0       30
De eerste voorstelling is echter wat overzichtelijker, en staat ook dichter bij de wijze waarop de elementen benaderd worden.  Je spreekt de elementen van een twee dimensionale array immers aan door er naartoe te verwijzen met twee indexwaarden, één voor de eerste dimensie en twee voor de tweede dimensie.

Meerdimensionale arrays ga je dus enkel gebruiken als je een verzameling van elementen via meerdere dimensies wil gaan benaderen.

Zoals we reeds merkten bij één dimensionale arrays, is het erg eenvoudig de elementen van dergelijke array te benaderen aan de hand van een For ... Next iteratiestructuur.  Deze beschikt immers altijd over een tellervariabele die over een bepaald numeriek bereik loopt, en voor elke waarde die de teller aanneemt wordt de body van de iteratie uitgevoerd.  Laat je de tellerwaarde lopen over het indexen bereik van een array (dus van de lower- tot de upperbound) dan kan je met elk element van de array dus een bepaalde actie uitvoeren.

Ook voor het benaderen van elementen van meerdimensionale arrays komen dergelijke For ... Next iteratiestructuren goed van pas.  Het verschil is dat we hier meerdere van die iteraties in elkaar gaan nesten.  Met bijvoorbeeld bij een twee dimensionale array als bedoeling de eerste iteratie te laten lopen over de verschillende rijen (elementen van de eerste dimensie) en de daarin geneste iteratie te laten lopen over de verschillende kolommen (elementen van de tweede dimensie).  Zo wordt dus voor alle rijen, per rij, alle kolommen overlopen.

Stel je voor dat we een twee dimensionale tabel met tien rijen en tien kolommen wensen op te vullen met de waardes 101 tot en met 200 (oplopend per kolom), dan kunnen we als volgt te werk gaan :
Visual Basic 2012 Broncode - Codevoorbeeld 126
Module Example2
    Sub Main()
        Dim rowCount As Integer = 10
        Dim columnCount As Integer = 10
        '
        Dim upperboundFirstDimension As Integer = rowCount - 1
        Dim upperboundSecondDimension As Integer = columnCount - 1
        '
        Dim values(upperboundFirstDimension, _
                   upperboundSecondDimension) As Integer
        '
        Dim startValue As Integer = 101
        '
        Dim rowIndex, columnIndex As Integer
        For rowIndex = 0 To upperboundFirstDimension
            For columnIndex = 0 To upperboundSecondDimension
                values(rowIndex, columnIndex) = startValue
                startValue += 1
                Console.Write(values(rowIndex, columnIndex) & " ")
            Next
            Console.WriteLine()
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Console Application Output
101 102 103 104 105 106 107 108 109 110
111 112 113 114 115 116 117 118 119 120
121 122 123 124 125 126 127 128 129 130
131 132 133 134 135 136 137 138 139 140
141 142 143 144 145 146 147 148 149 150
151 152 153 154 155 156 157 158 159 160
161 162 163 164 165 166 167 168 169 170
171 172 173 174 175 176 177 178 179 180
181 182 183 184 185 186 187 188 189 190
191 192 193 194 195 196 197 198 199 200
Per rij worden dus alle kolommen overlopen om het element in de volgende kolom steeds met een geïncrementeerde waarde op te vullen.

Een iets andere versie zou de aan elk element toe-te-kennen waarde kunnen baseren op de rij en kolom indexwaarde :
Visual Basic 2012 Broncode - Codevoorbeeld 127
Module Example3
    Sub Main()
        Dim rowCount As Integer = 10
        Dim columnCount As Integer = 10
        '
        Dim upperboundFirstDimension As Integer = rowCount - 1
        Dim upperboundSecondDimension As Integer = columnCount - 1
        '
        Dim values(upperboundFirstDimension, upperboundSecondDimension) As Integer
        '
        Dim baseValue As Integer = 101
        '
        Dim rowIndex, columnIndex As Integer
        For rowIndex = 0 To upperboundFirstDimension
            For columnIndex = 0 To upperboundSecondDimension
                values(rowIndex, columnIndex) = _
                                       baseValue + (rowIndex * 10) + columnIndex
                Console.Write(values(rowIndex, columnIndex) & " ")
            Next
            Console.WriteLine()
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Console Application Output
101 102 103 104 105 106 107 108 109 110
111 112 113 114 115 116 117 118 119 120
121 122 123 124 125 126 127 128 129 130
131 132 133 134 135 136 137 138 139 140
141 142 143 144 145 146 147 148 149 150
151 152 153 154 155 156 157 158 159 160
161 162 163 164 165 166 167 168 169 170
171 172 173 174 175 176 177 178 179 180
181 182 183 184 185 186 187 188 189 190
191 192 193 194 195 196 197 198 199 200
Heb je moeite om dergelijk bovenstaand algoritme op te stellen, ga dan als volgt te werk :

Vraag : Wat moeten we doen voor elk element?  Wat wordt herhaald?
Antwoord : Er een waarde aan toekennen.  Of in het algemeen : in de tabel op een bepaalde rij- en kolomindex een waarde bewaren :
values(rowIndex, columnIndex) = value
Bekijk wat hier herhaald moet worden voor welke values :
           rowIndex   columnIndex value
           0          0           101
           0          1           102
           0          2           103
           ...        ...         ...
           0          9           110
           1          0           111
           1          1           112
           1          2           113
           ...        ...         ...
           1          9           120
           ...        ...         ...
           9          9           200
Zo zien we een overzicht van welke waarden aan welke elementen (op welke rij- en kolomindexwaardes) moeten worden toegekend.
Er is een rechtstreeks verband tussen de waarden van de rij en de kolom en de toe te kennen waarde die zich op dezelfde regel bevinden, namelijk :
value = baseValue + (rowIndex * 10) + columnIndex
Deze formule kan dan dus ook gebruikt worden in plaats van de formule uit de eerste versie.

De laatste versie zou je iets dynamischer kunnen noemen omdat je hier nu over een formule beschikt die per element kan bepalen wat de waarde is.  En waarbij de toe te kennen waarde nu dus niet meer gebaseerd wordt op het iteratief benaderen van deze elementen.

In dit en vorig voorbeeld werken we met twee dimensionale arrays, ook drie, vier, vijf, ...,  dimensionale arrays kunnen worden aangemaakt.  Arrays met meer dan twee a drie dimensies worden echter zelden gebruikt.

7.7.2. Oefeningen

Opgave :

Maak een programma dat een tabel met een door de gebruiker bepaald aantal rijen en kolommen opvult met oplopende getallen startend bij een waarde ook opgegeven door de gebruiker.

Breng ter controle de inhoud van de tabel op de console.

Verschuif de tabel inhoud, en breng ook de verschuifde tabelinhoud op de console.  Let op : het is de bedoeling de tabelinhoud te verschuiven, en niet opnieuw te genereren.
Console Application Output
Row Count ?
5
Column Count ?
9
Start Value ?
11

11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28
29 30 31 32 33 34 35 36 37
38 39 40 41 42 43 44 45 46
47 48 49 50 51 52 53 54 55

55 11 12 13 14 15 16 17 18
19 20 21 22 23 24 25 26 27
28 29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
Oplossing :
Visual Basic 2012 Broncode - Codevoorbeeld 128
Module Exercise1Solution
    Sub Main()
        Console.WriteLine("Row Count ?")
        Dim rowCount As Integer = Console.ReadLine()
        Console.WriteLine("Column Count ?")
        Dim columnCount As Integer = Console.ReadLine()
        '
        Dim rowUpperbound As Integer = rowCount - 1
        Dim columnUpperbound As Integer = columnCount - 1
        Dim values(rowUpperbound, columnUpperbound) As Integer
        '
        Console.WriteLine("Start Value ?")
        Dim startValue As Integer = Console.ReadLine()
        Console.WriteLine()
        '
        Dim rowIndex, columnIndex, value As Integer
        value = startValue
        For rowIndex = 0 To rowUpperbound
            For columnIndex = 0 To columnUpperbound
                values(rowIndex, columnIndex) = value
                value += 1
                Console.Write(values(rowIndex, columnIndex) & " ")
            Next
            Console.WriteLine()
        Next
        Console.WriteLine()
        '
        Dim backup As Integer
        backup = values(rowUpperbound, columnUpperbound)
        For rowIndex = rowUpperbound To 1 Step -1
            For columnIndex = columnUpperbound To 1 Step -1
                values(rowIndex, columnIndex) = values(rowIndex, columnIndex - 1)
            Next
            values(rowIndex, 0) = values(rowIndex - 1, columnUpperbound)
        Next
        For columnIndex = columnUpperbound To 1 Step -1
            values(0, columnIndex) = values(0, columnIndex - 1)
        Next
        values(0, 0) = backup
        '
        For rowIndex = 0 To rowUpperbound
            For columnIndex = 0 To columnUpperbound
                Console.Write(values(rowIndex, columnIndex) & " ")
            Next
            Console.WriteLine()
        Next
        Console.WriteLine()
        '
        Console.ReadLine()
    End Sub
End Module
Opgave :
Maak een programma dat een tabel met een door de gebruiker bepaald aantal rijen en kolommen opvult met oplopende getallen startend bij een waarde ook opgegeven door de gebruiker.

Breng ter controle de inhoud van de tabel op de console.

Creëer nu een tweede tabel, waarin de waarden getransponeerd staan, en breng ook de tabelinhoud van deze tabel op de console.
Console Application Output
Row Count ?
8
Column Count ?
3
Start Value ?
11

11 12 13
14 15 16
17 18 19
20 21 22
23 24 25
26 27 28
29 30 31
32 33 34

11 14 17 20 23 26 29 32
12 15 18 21 24 27 30 33
13 16 19 22 25 28 31 34
Oplossing :
Visual Basic 2012 Broncode - Codevoorbeeld 129
Module Exercise2Solution
    Sub Main()
        Console.WriteLine("Row Count ?")
        Dim rowCount As Integer = Console.ReadLine()
        Console.WriteLine("Column Count ?")
        Dim columnCount As Integer = Console.ReadLine()
        '
        Dim upperboundFirstDimension As Integer = rowCount - 1
        Dim upperboundSecondDimension As Integer = columnCount - 1
        '
        Dim matrix(upperboundFirstDimension, _
                   upperboundSecondDimension) As Integer
        '
        Console.WriteLine("Start Value ?")
        Dim startValue As Integer = Console.ReadLine()
        Console.WriteLine()
        '
        Dim rowIndex, columnIndex, value As Integer
        value = startValue
        For rowIndex = 0 To upperboundFirstDimension
            For columnIndex = 0 To upperboundSecondDimension
                matrix(rowIndex, columnIndex) = value
                value += 1
            Next
        Next
        '
        For rowIndex = 0 To upperboundFirstDimension
            For columnIndex = 0 To upperboundSecondDimension
                Console.Write(matrix(rowIndex, columnIndex) & " ")
            Next
            Console.WriteLine()
        Next
        Console.WriteLine()
        '
        Dim backup As Integer = upperboundFirstDimension
        upperboundFirstDimension = upperboundSecondDimension
        upperboundSecondDimension = backup
        Dim transpone(upperboundFirstDimension, _
                      upperboundSecondDimension) As Integer
        For rowIndex = 0 To upperboundFirstDimension
            For columnIndex = 0 To upperboundSecondDimension
                transpone(rowIndex, columnIndex) = _
                                          matrix(columnIndex, rowIndex)
                Console.Write(transpone(rowIndex, columnIndex) & " ")
            Next
            Console.WriteLine()
        Next
        '
        Console.ReadLine()
    End Sub
End Module

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.