homeboekenlinksledenabonneer je :Blijf op de hoogte door je te abonneren op de vbvoorbeelden RSS Niews Feed!Blijf op de hoogte door vbvoorbeelden te volgen op Twitter!Blijf op de hoogte door fan te worden van vbvoorbeelden op Facebook!
Visual Basic 2008 en 2010 Voorbeelden en Boeken Microsoft Visual Studio 2010Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

visual basic 2008 voorbeelden en boeken / visual basic 2010 voorbeelden en boeken

2.4. Uitbreiding Herhalingsstructuren

Print Email Deel op FacebookDeel op TwitterDeel op DiggBookmark op Google BookmarksDeel op del.icio.usOverige Sociale Netwerksites...

Dit artikel is gepubliceerd op woensdag 28 april 2010 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

2.4.1. Do While ... Loop

Hieronder een voorbeeld van een iteratie structuur waar we de getallen 1 tot en met 10 op de console brengen :
Visual Basic Broncode
Module Example1
    Sub Main()
        Dim value As Integer
        '
        Do While value < 10
            value = value + 1
            Console.WriteLine(value)
        Loop
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
1
2
3
4
5
6
7
8
9
10

2.4.2. Do Until ... Loop

Een andere variant bruikbaar in een iteratiestructuur is de Do Until voorwaarde ... Loop structuur, hier wordt de body van de lus uitgevoerd totdat aan de voorwaarde is voldaan, of dus zolang niet aan de voorwaarde is voldaan :
Visual Basic Broncode
Module Example2
    Sub Main()
        Dim value As Integer
        '
        Do Until value >= 10
            value = value + 1
            Console.WriteLine(value)
        Loop
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
1
2
3
4
5
6
7
8
9
10

2.4.3. Do ... Loop While ... en Do ... Loop Until ...

Naast de Do While ... Loop en de Do Until ... Loop varianten is het ook mogelijk de voorwaarde op het einde te plaatsen : Do ... Loop While ... en Do ... Loop Until .... Deze hebben als groot verschil dat de body van de lus minimaal 1 keer wordt uitgevoerd. Wat niet perse het geval zal zijn als die voorwaarde vooraan staat.

Hieronder zie je algoritmes die ook de getallen 1 tot en met 10 op de console brengt, maar dan met de voorwaarde achteraan gedefinieerd.
Visual Basic Broncode
Module Example3
    Sub Main()
        Dim value As Integer
        '
        Do
            value = value + 1
            Console.WriteLine(value)
        Loop While value < 10
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
1
2
3
4
5
6
7
8
9
10
Visual Basic Broncode
Module Example4
    Sub Main()
        Dim value As Integer
        '
        Do
            value = value + 1
            Console.WriteLine(value)
        Loop Until value >= 10
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
1
2
3
4
5
6
7
8
9
10
Merk op dat als men een While versie omzet naar een Until versie of omgekeerd, men de voorwaarde moet gaan kantelen. Bijvoorbeeld "zolang een getal kleiner is of gelijk is aan 10" heeft als voorwaarde getal <= 10.
Een getal is niet <= 10, slechts wanneer het groter is dan 10. Dus de Until versie is "totdat getal > 10".

Stel : men wenst aan de gebruiker van het programma te vragen hoeveel getallen er op de console moeten komen, waarna het programma startende bij 1 alle volgende gehele getallen afdrukt tot het door de gebruiker opgegeven aantal bereikt is.
Visual Basic Broncode
Module Example5
    Sub Main()
        Console.WriteLine("Highest Value ?")
        Dim highest As Integer = Console.ReadLine()
        '
        Console.WriteLine("Row :")
        Dim value As Integer
        Do
            value = value + 1
            Console.WriteLine(value)
        Loop Until value >= highest
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
Highest Value ?
5
Row :
1
2
3
4
5
Het programma functioneert echter niet goed wanneer de gebruiker 0 invoert. Hierbij wordt toch een "Row" met 1 als resultaat gegeven, terwijl men hier echter een lege reeks zou verwachten.
Visual Basic Output
Highest Value ?
0
Row :
1
Door de afbreekvoorwaarde vooraan te plaatsen voldoet het programma volledig aan de vooropgestelde vereisten.
Visual Basic Broncode
Module Example6
    Sub Main()
        Console.WriteLine("Highest Value ?")
        Dim highest As Integer = Console.ReadLine()
        '
        Console.WriteLine("Row :")
        Dim value As Integer
        Do Until value >= highest
            value = value + 1
            Console.WriteLine(value)
        Loop
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
Highest Value ?
5
Row :
1
2
3
4
5
Visual Basic Output
Highest Value ?
0
Row :
Stel dat we een programma wensen die herhaaldelijk om een getal vraagt tot een getal wordt ingevoerd die groter is of gelijk aan nul.
Dan kunnen we als volgt tewerk gaan :
Visual Basic Broncode
Module Example7
    Sub Main()
        Dim value As Integer
        '
        Do
            Console.Write("Enter a Value ( 0 or more ) : ")
            value = Console.ReadLine()
        Loop Until value >= 0
        '
        Console.WriteLine("Correct Entered Value : " & value)
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
Enter a Value ( 0 or more ) : -8
Enter a Value ( 0 or more ) : -2
Enter a Value ( 0 or more ) : 0
Correct Entered Value : 0
Visual Basic Output
Enter a Value ( 0 or more ) : -3
Enter a Value ( 0 or more ) : 5
Correct Entered Value : 5
Visual Basic Output
Enter a Value ( 0 or more ) : 0
Correct Entered Value : 0
Bemerkt dat hier de afbreekvoorwaarde achteraan staat. We wensen immer dat hier steeds minstens één getal wordt ingevoerd.

Hadden we nu de afbreekvoorwaarde vooraan geplaatst dan geeft dit niet het gewenste effect :
Visual Basic Broncode
Module Example8
    Sub Main()
        Dim value As Integer
        '
        Do Until value >= 0
            Console.Write("Enter a Value ( 0 or more ) : ")
            value = Console.ReadLine()
        Loop
        '
        Console.WriteLine("Correct Entered Value : " & value)
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
Correct Entered Value : 0
We krijgen hier meteen als output, zonder dat we een getal hebben ingevoerd, dat de ingevoerde waarde nul is. Wat uiteraard niet klopt.

2.4.4. For ... Next

Naast de Do ... Loop iteratiestructuren bestaat er ook nog een For ... Next iteratiestructuur. Bij het gebruik van deze structuur ga je niet rechtstreeks een voorwaarde formuleren hoe lang of tot wanneer iets herhaald moet worden, maar ga je eerder een "tellervariabele" over een bepaald bereik laten lopen, om dan per waarde voor die teller de body van die lus te laten herhalen.

Hieronder opnieuw voorbeeld waar de getallen 1 tot en met 10 worden afgedrukt :
Visual Basic Broncode
Module Example9
    Sub Main()
        Dim value As Integer
        '
        For value = 1 To 10
            Console.WriteLine(value)
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
1
2
3
4
5
6
7
8
9
10
De body van de lus wordt dus herhaald voor iedere waarde de tellervariabele ( value ) aanneemt. Startende bij 1, steeds verhogend met 1 tot en met 10 zorgt er dus voor dat de body hier 10 keer zal worden uitgevoerd.

Niet steeds dient de startwaarde 1 te zijn, eender welk geheel getal kan als startwaarde opgegeven worden.
Visual Basic Broncode
Module Example10
    Sub Main()
        Dim value As Integer
        '
        For value = 10 To 15
            Console.WriteLine(value)
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
10
11
12
13
14
15
By default is de stapwaarde 1, en zal de teller variabele dus met 1 worden verhoogd per uitvoering van de body. Maar ook hiervan kan men afwijken, dit kan door een optionele Step clausule op te nemen, waar na het keyword Step een Integer expressie wordt geplaatst die de alternatieve stapwaarde aangeeft.
Visual Basic Broncode
Module Example11
    Sub Main()
        Dim value As Integer
        '
        For value = 2 To 10 Step 2
            Console.WriteLine(value)
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
2
4
6
8
10
Definieert men geen Step clausule ( of by default dus ) dan moet je er dus Step 1 bij denken.

Ook negatieve stapwaarden zijn mogelijk. Hierbij dient men opletten dat de startwaarde hoger moet zijn dan de eindwaarde, doet men dit niet dan zal de body van de lus nooit worden uitgevoerd.
Visual Basic Broncode
Module Example12
    Sub Main()
        Dim value As Integer
        '
        For value = 10 To 0 Step -2
            Console.WriteLine(value)
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
10
8
6
4
2
0
Ook niet gehele getallen als start-, eind- en stap waarde zijn mogelijk, maar dan moet de tellervariabele wel van een niet-integer numeriek formaat worden gedeclareerd.

Een groot verschil met de andere iteratiestructuren is dus dat er altijd met een teller wordt gewerkt, en dat deze dan ook nog eens automatisch verhoogd wordt na het uitvoeren van de body van de lus.

In vorige voorbeeld werd de start-, eind- en stap waarde steeds geformuleerd aan de hand van een letterlijke Integer value ( een Integer literal ).
Maar men kan hiervoor eender welke Integer expressie gebruiken, bijvoorbeeld ook Integer variabelen.
Visual Basic Broncode
Module Example13
    Sub Main()
        Dim countValue As Integer
        Dim startValue As Integer = 1
        Dim endValue As Integer = 10
        Dim stepValue As Integer = 2
        '
        Console.WriteLine("values during iteration :")
        For countValue = startValue To endValue Step stepValue
            Console.WriteLine("count value : " & countValue)
            '
            countValue = countValue + 1
            startValue = startValue + 1
            endValue = endValue + 1
            stepValue = stepValue + 1
        Next
        '
        Console.WriteLine("values after iteration :")
        Console.WriteLine("count value : " & countValue)
        Console.WriteLine("start value : " & startValue)
        Console.WriteLine("end value   : " & endValue)
        Console.WriteLine("step value  : " & stepValue)
        '
        Console.ReadLine()
    End Sub
End Module
Visual Basic Output
values during iteration :
count value : 1
count value : 4
count value : 7
count value : 10
values after iteration :
count value : 13
start value : 5
end value   : 14
step value  : 6
Als je de output van dit voorbeeld bekijkt, bemerk je dat de start-, eind- en stapwaarden slecht één maal geëvalueerd werden. Het is dus niet omdat de variabelen die deze waarden uitdrukten van waarde wijzigen tijdens de uitvoering van de iteraties, dat deze gewijzigde waarden zullen worden gebruikt.

Wel kan men de teller waarde aanpassen.

Het wijzigen van die start-, eind- en stapwaarden in de body van de lus werkt hier dus enkele verwarrend.
Dit is dus een voorbeeld van hoe je een For ... Next structuur niet moet gaan gebruiken.

2.4.5. For Each ... Next

Verderop zullen we nog zien hoe men over de elementen van een collectie kan itereren aan de hand van de For Each ... Next iteratiestructuur.

2.4.6. Oefeningen

Opgave :

Maak een programma om de faculteit van een door de gebruiker ingevoerd getal te bepalen. We gaan er simpelweg vanuit dat de gebruiker een getal invoert die groter is dan 0.

De faculteit van een getal X = X * (X-1) * (X-2) * ... * 1, dus bijvoorbeeld 5! = 5 * 4 * 3 * 2 * 1 = 120.
Visual Basic Output
Value ?
5
5! = 120
Oplossing :
Visual Basic Broncode
Module Exercise1Solution
    Sub Main()
        Console.WriteLine("Value ?")
        Dim value As Integer = Console.ReadLine()
        '
        Dim factorial As Integer = value
        Dim factor As Integer = value - 1
        '
        For factor = value - 1 To 2 Step -1
            factorial = factorial * factor
        Next
        '
        Console.WriteLine(value & "! = " & factorial)
        '
        Console.ReadLine()
    End Sub
End Module
Opgave :
Breng alle seconden van alle minuten van alle uren in onderstaand formaat op de console.
Visual Basic Output
00h00m00s
00h00m01s
...
00h00m59s
00h01m00s
...
00h59m59s
01h00m00s
...
23h59m59s
Oplossing :
Visual Basic Broncode
Module Exercise2Solution
    Sub Main()
        Dim hours, minutes, seconds As Integer
        Dim timeLabel As String
        For hours = 0 To 23
            For minutes = 0 To 59
                For seconds = 0 To 59
                    timeLabel = ""
                    If hours < 10 Then
                        timeLabel = "0"
                    End If
                    timeLabel = timeLabel & hours & "h"
                    If minutes < 10 Then
                        timeLabel = timeLabel & "0"
                    End If
                    timeLabel = timeLabel & minutes & "m"
                    If seconds < 10 Then
                        timeLabel = timeLabel & "0"
                    End If
                    timeLabel = timeLabel & seconds & "s"
                    Console.WriteLine(timeLabel)
                Next
            Next
        Next
        Console.ReadLine()
    End Sub
End Module
Opgave :
Maak een programma om een totaal aantal seconden om te zetten naar een formaat uitgedrukt in aantal dagen, aantal uren, aantal minuten en aantal seconden.

Het omzetten wordt herhaald zolang een getal verschillend van 0 wordt ingevoerd.

Bij het invoeren van een negatieve waarde, geeft het programma een foutmelding.

Zorg ervoor dat je programma ( met dezelfde input ) exact dezelfde uitvoer geeft als onderstaand programma-verloop toont.

Let er op dat nergens in het resultaat "0 days", "0 hours", "0 minutes" of "0 seconds" wordt opgenomen.
Visual Basic Output
Seconds ?
-1
Error : Only positive values are accepted !
Seconds ?
1000000
Result :
11 days
13 hours
46 minutes
40 seconds
Seconds ?
999960
Result :
11 days
13 hours
46 minutes
Seconds ?
49600
Result :
13 hours
46 minutes
40 seconds
Seconds ?
2800
Result :
46 minutes
40 seconds
Seconds ?
2760
Result :
46 minutes
Seconds ?
0
End.
Oplossing :
Visual Basic Broncode
Module Exercise3Solution
    Sub Main()
        Dim totalSeconds, remainingSeconds As Integer
        Dim days, hours, minutes, seconds As Integer
        '
        Do
            Console.WriteLine("Seconds ?")
            totalSeconds = Console.ReadLine()
            If totalSeconds = 0 Then
                Console.WriteLine("End.")
            Else
                If totalSeconds < 0 Then
                    Console.WriteLine("Error : " & _
                                      "Only positive values are accepted !")
                Else
                    remainingSeconds = totalSeconds
                    days = remainingSeconds \ 86400
                    remainingSeconds = remainingSeconds - days * 86400
                    hours = remainingSeconds \ 3600
                    remainingSeconds = remainingSeconds - hours * 3600
                    minutes = remainingSeconds \ 60
                    seconds = remainingSeconds - minutes * 60
                    Console.WriteLine("Result :")
                    If days > 0 Then
                        Console.WriteLine(days & " days")
                    End If
                    If hours > 0 Then
                        Console.WriteLine(hours & " hours")
                    End If
                    If minutes > 0 Then
                        Console.WriteLine(minutes & " minutes")
                    End If
                    If seconds > 0 Then
                        Console.WriteLine(seconds & " seconds")
                    End If
                End If
            End If
        Loop Until totalSeconds = 0
        '
        Console.ReadLine()
    End Sub
End Module
Opgave :
Maak een programma om een reeks ( met ongedefinieerde lengte ) van gehele getallen verschillend van 0 op te tellen.

Het aantal getallen dat wordt opgeteld is niet vastgelegd, in onderstaand voorbeeld zijn dit er 5, maar dit kunnen er ook 10 zijn , of 20, of 1, ... .

Zorg ervoor dat uw oplossing exact verloopt ( met dezelfde input ) zoals in onderstaand programma-verloop wordt gedemonstreerd.
Visual Basic Output
1
+
2
+
3
+
4
+
5
+
0
=
15
Visual Basic Output
0
=
0
Oplossing :
Visual Basic Broncode
Module Exercise4Solution
    Sub Main()
        Dim number, sum As Integer
        '
        number = Console.ReadLine()
        Do Until number = 0
            Console.WriteLine("+")
            sum = sum + number
            number = Console.ReadLine()
        Loop
        Console.WriteLine("=")
        Console.WriteLine(sum)
        '
        Console.ReadLine()
    End Sub
End Module
Opgave :
Maak een programma om een reeks ( met ongedefinieerde lengte ) van gehele getallen op te tellen of af te trekken.

Het aantal getallen in de berekening is niet vastgelegd.

We gaan er voor de eenvoud vanuit dat steeds correct operatoren ( +, - of = ) worden ingevoerd. Je hoeft hierop dus geen controle toe te passen.

Zorg ervoor dat uw oplossing exact verloopt ( met dezelfde input ) zoals in onderstaand programma-verloop wordt gedemonstreerd.
Visual Basic Output
1
=
1
Visual Basic Output
1
+
2
=
3
Visual Basic Output
1
-
-5
=
6
Visual Basic Output
1
+
2
-
3
-
4
+
5
-
0
+
0
=
1
Oplossing :
Visual Basic Broncode
Module Exercise5Solution
    Sub Main()
        Dim number, result As Integer
        Dim operatorSymbol As String
        '
        result = Console.ReadLine()
        operatorSymbol = Console.ReadLine()
        Do Until operatorSymbol = "="
            number = Console.ReadLine()
            If operatorSymbol = "+" Then
                result = result + number
            Else
                If operatorSymbol = "-" Then
                    result = result - number
                End If
            End If
            operatorSymbol = Console.ReadLine()
        Loop
        Console.WriteLine(result)
        '
        Console.ReadLine()
    End Sub
End Module

Dit artikel is gepubliceerd op woensdag 28 april 2010 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

Visual Basic 2008 & 2010 Boeken

Het Groene Visual Basic 2008 & 2010 Voorbeelden Boek Het Blauwe Visual Basic 2008 & 2010 Voorbeelden Boek Het Rode Visual Basic 2008 & 2010 Voorbeelden Boek

Bevalt een artikel je, dan kan je de inhoud van vbvoorbeelden ook reclamevrij in boekvorm verkrijgen.

De inhoud is verdeeld over 3 boeken, Het Groene, Het Blauwe en Het Rode Visual Basic 2008 & 2010 Voorbeelden Boek.

Klik hier voor meer informatie.

Berichten

Fast UML Sequence Diagram Editor