## Visual Basic in 12 Easy Lessons vel10.htm

- What You'll Learn
- The Do While Loop
- The Do Until Loop
- The Other Do Loops
- The For Loop
- Homework
  - General Knowledge
  - Write Code That...
  - Find the Bug
  - Extra Credit

#
Lesson 5, Unit 10

##
Looping

###
What You'll Learn

- The Do While Loop
- The Do Until Loop
- The Other Do Loops
- The For Loop

Now you're really ready to write powerful programs! You've learned some controls, you've defined some variables, and you've written programs that make decisions. It's now time to learn how to write programs that perform repetitive data processing. When a computer does something over and over, the computer is said to be looping.

Computers don't get bored. The primary strength of computers is their capability to loop through a series of calculations over and over very quickly. Computers can process every customer balance, calculate sales averages among many divisions, and display data for each company employee.

This unit describes how you can add looping to Visual Basic programs so that the programs can process several data values using looping statements. Loops don't just help when you have large amounts of data to process. Loops also enable you to correct user errors and repeat certain program functions when the user requests a repeat.

###
The Do While Loop

Concept: The Do statement supports several different loop formats. The Do While loop is perhaps the most common looping statement that you'll put in Visual Basic programs.

> > Definition: A block consists of one or more program statements.

The Do While statement works with relational expressions just as the If statement does. Therefore, the six relational operators that you learned about in the previous lesson work as expected here. Rather than control the one-time execution of a single block of code, however, the relational expression controls the looping statements.

The code that you've seen so far inside event procedures has been sequential code that executed one statement following another in the order that you typed the statements. Looping changes things a bit. Many lines of your programs will still execute sequentially, but a loop will cause blocks of code to repeat one or more times.

Like the If statement that ends with an End If statement, a loop will always be a multiline statement that includes an obvious beginning and ending of the loop. Here is the format of the Do While loop:

    Do While (relational test)

     Block of one or more Visual Basic statements

    Loop

> > Definition: An infinite loop repeats forever.

The block of code continues looping as long as the relational test is true. Whether you insert one or several lines of code for the block doesn't matter. It's vital, however, that the block of code somehow change a variable used in the relational test. The block of code keeps repeating as long as the Do While loop's relational test continues to stay true. Eventually, the relational test must become false or your program will enter an infinite loop and the user will have to break the program's execution through an inelegant means, such as pressing the Ctrl+Break key combination.

> > Warning: Even if you provide an Exit command button as you've seen used in this book's applications, the program will often ignore the user's Exit command button click if the program enters an infinite loop.

Figure 10.1 illustrates how the Do While loop works. As long as the relational test is true, the block of code in the body of the loop continues executing. When the relational test becomes false, the loop terminates. After the loop terminates, Visual Basic begins program execution at the statement following the Loop statement because Loop signals the end of the loop.

Figure 10.1. The Do While loop's action continues while the relational test is true.

> > Note: As soon as the relational test becomes false, the loop terminates and doesn't execute even one more time. The Do While's relational test appears at the top of the loop. Therefore, if the relational test is false the first time that the loop begins, the body of the loop will never execute.

Throughout this book, you'll see indention used for the body of the loop code. By indenting the body of the loop to the right of the loop's introduction and terminating statements, you'll make it easier to spot where the loop begins and ends.

Stop and Type: Listing 10.1 contains a section of an event procedure that contains a Do While loop that asks the user for an age. If the user enters an age less than 10 or more than 99, the program beeps at the error and displays another input box asking for the age. The program continues looping, asking for the age, as long as the user enters an age that's out of range.

Review: The Do While loop continues executing a block of Visual Basic statements as long as a relational test is true. As soon as the relational test becomes false, the loop terminates.

Listing 10.1. The Do While loop executes as long as the relational test is true.

    1: Dim StrAge As String

    2: Dim Age As Integer

    3: ' Get the age in a string variable

    4: StrAge = InputBox$("How old are you?", "Age Ask")

    5: ' Check for the Cancel command button

    6: If (StrAge = "")
    Then

    7: End

    8: End If

    9: ' Cancel was not pressed, so convert Age to integer

    10: Age = Val(StrAge)

    11: ' Loop if the age is not in the correct range

    12: Do While ((Age < 10) Or (Age > 99))

    13: ' The user's age is out of range

    14: Beep

    15:
    MsgBox "Your age must be between 10 and 99", MB_ICONEXCLAMATION, "Error!"

    16: StrAge = InputBox("How old are you?", "Age Ask")

    17: ' Check for the Cancel command button

    18: If (StrAge = "") Then

    19: End

    20: End If

    21: Age = Val(StrAge)

    22: Loop

Output: Figure 10.2 shows the message box error displayed in line 15 if the user enters an age value that's less than 10 or more than 99.

Figure 10.2. The user sees this message box as long as the age is out of range.

Analysis: Lines 1 and 2 define two variables, a string and an integer. The code uses the string variable to capture the return value from the InputBox$() function. Use a string variable so that you can test for the Cancel button because, as you learned in the previous lesson, InputBox$() returns a null string if the user presses Cancel. If the user presses Cancel, the code terminates the entire program with an End statement (lines 7 and 19). If the user enters an age (and did not press Cancel), the code converts the string age to an integer and checks to make sure that the age is within the range of 10 to 99.

Line 12 begins a loop if the age is less than 10 or more than 99. The loop continues executing from line 13 to the end of the loop in line 22. If the age is out of range, the body of the loop executes. Line 14 beeps, thus sending an audible signal to the user that something is wrong. Line 15 displays an error message box (the one shown in Figure 10.2) and after the user presses OK at the message box, the user is once again asked for an age with an InputBox$() function shown on line 16. The loop then checks to make sure that the user didn't press Cancel (lines 17 through 20) and, if not, the code converts the string age to an integer and the loop begins once again. If the age entered in the previous pass of the loop falls within the valid age range, the program finishes (any code that exists past line 22 executes). Otherwise, the loop begins once again.

The code contains some redundancy. For example, lines 4 and 16 contain almost the same InputBox$() function, and the same check for a Cancel command button press appears twice in the program. There are other looping statements that you'll learn about later in this chapter; those statements can help simplify this code by removing some of the redundancy.

Perhaps the most important thing to note about the Do While loop in Listing 10.1 is that the body of the loop provides a way for the relational test to terminate. Line 12's relational test uses the Age variable that the body of the loop reassigns each time the loop's block of code executes. Therefore, assuming that the user enters a different value for the age, the loop will test against a different set of relational values in line 12 and, it is hoped, the relational test will fail (which would mean that the age is inside the range) and the program will stop looping. If the loop body did nothing with the relational test variable, the loop would continue forever.

###
The Do Until Loop

Concept: Whereas the Do While loop continues executing the body of the loop as long as the relational test is true, the Do Until loop executes the body of the loop as long as the relational test is false. The program's logic at the time of the loop determines which kind of loop works best in a given situation.

The Do Until loop works almost exactly like the Do While except that the Do Until loop continues executing the body of the loop until the relational test is true. Like the Do While, the Do Until is a multiline looping statement that can execute a block of code that's one or more lines long.

Here is the format of the Do Until:

    Do Until (relational test)

     Block of one or more Visual Basic statements

    Loop

Again, keep in mind that the relational test must be false for the loop to continue. Figure 10.3 illustrates how the Do Until works.

Figure 10.3. The Do Until loop's action continues while the relational test is false.

Stop and Type: You can use the Do While or the Do Until for almost any loop. Listing 10.2 contains the age-checking event procedure that contains a Do Until loop. The loop ensures that the age falls between two values. As you can see, the relational test for the Do Until is the opposite of that used in Listing 10.1's Do While loop.

> > Note: Use the loop that makes for the cleanest and clearest relational test. Sometimes, the logic makes the Do While clearer, whereas other loops seem to work better when you set them up with the Do Until loop.

Review: The Do Until loop continues executing a block of Visual Basic statements as long as a relational test is false. As soon as the relational test becomes true (the loop is said to Do a loop until the condition becomes false), the loop terminates and the program continues on the line that follows the closing Loop statement.

Listing 10.2. The Do Until loops until the relational test becomes true.

    1: Dim StrAge As String

    2: Dim Age As Integer

    3: ' Get the age in a string variable

    4: StrAge =
    InputBox$("How old are you?", "Age Ask")

    5: ' Check for the Cancel command button

    6: If (StrAge = "") Then

    7: End

    8: End If

    9: ' Cancel was not pressed, so convert Age to integer

    10: Age = Val(StrAge)

    11: ' Loop if the
    age is not in the correct range

    12: Do Until ((Age >= 10) And (Age <= 99))

    13: ' The user's age is out of range

    14: Beep

    15: MsgBox "Your age must be between 10 and 99", MB_ICONEXCLAMATION, "Error!"

    16: StrAge =
    InputBox("How old are you?", "Age Ask")

    17: ' Check for the Cancel command button

    18: If (StrAge = "") Then

    19: End

    20: End If

    21: Age = Val(StrAge)

    22: Loop

Analysis: Line 12 is the only line that marks the difference between Listing 10.1 and 10.2. The age must now fall within the valid range for the loop to terminate.

> > Note: There is really no advantage of using Do While or Do Until. Use whichever one seems to flow the best for any given application.

###
The Other Do Loops

Concept: There is another pair of Do loops that works almost exactly like the two previous sections' loops. Do-Loop While and the Do-Loop Until look very much like their counterparts that you learned earlier. Nevertheless, these new loop formats check their relational tests at the bottom of the loop rather than at the top.

If a loop begins with a single Do statement, the loop ends with either Loop While or Loop Until. Here is the format of the Do-Loop While:

    Do

     Block of one or more Visual Basic statements

    Loop Until (relational test)

> > Tip: The dash in Do-Loop While serves to remind you that the body of the loop comes before the Loop While statement. The dash in the Do-Loop Until performs the same purpose.

That Do looks lonely by itself, doesn't it? Figure 10.4 illustrates the flow of the Do-Loop While loop's execution.

Figure 10.4. The Do-Loop While loop doesn't check for the relational test until the bottom of the loop body.

Notice that the Do-Loop While loop's relational test appears at the bottom of the loop instead of at the top of the loop. You'll use the Do-Loop While loop when you want the body of the loop to execute at least one time. Often, by placing the relational test at the bottom of the loop, you can eliminate redundant code that otherwise might be required if you used Do While.

To complete the loop statements, Visual Basic also supports a Do-Loop Until statement. Like the Do-Loop While, the Do-Loop Until statement tests the relational test at the bottom of the loop. Therefore, the body of the loop executes at least once no matter what the relational test turns out to be. The loop continues as long as the relational test remains false. Figure 10.5 illustrates the action of the Do-Loop Until.

Figure 10.5. The Do-Loop Until loop checks for a false relational test at the bottom of the loop body.

Stop and Type: Listing 10.3 contains the age-checking event procedure that's much shorter than the previous versions. The relational test appears at the bottom of the loop, so the extra InputBox$() function call is not needed.

Review: The relational test appears at the bottom of the loop if you use the Do-Loop While loop statement. The body of the loop always executes at least once. The body of the loop executes more than once as long as the relational test stays true. There is a corresponding Do-Loop Until statement that checks for a false condition at the bottom of the loop's body.

Listing 10.3. Use the Do-Loop While to check the relation at the bottom of the loop.

    1: Dim StrAge As String

    2: Dim Age As Integer

    3: Do

    4: StrAge = InputBox("How old are you?", "Age Ask")

    5: ' Check for the Cancel command button

    6: If (StrAge = "") Then

    7: End

    8: End If

    9: Age =
    Val(StrAge)

    10: If ((Age < 10) Or (Age > 99)) Then

    11: ' The user's age is out of range

    12: Beep

    13: MsgBox "Your age must be between 10 and 99", MB_ICONEXCLAMATION, "Error!"

    14: End If

    15: Loop While ((Age < 10) Or (Age
    > 99))

Analysis: The loop begins almost immediately in line 3. The loop's body will always execute at least once, so the InputBox$() appears right inside the loop. By placing the InputBox$() function inside the loop, you eliminate the need to put this function in the code twice (once before the loop and once inside the loop, as was necessary using the previous looping statements in Listings 10.1 and 10.2).

Line 10 must check to make sure that the InputBox$() value is in or out of the age range so that the message box error can be displayed.

> > Note: In this simple application of the looping statements that you've seen here, the Do-While loop required less code than the Do While and Do Until loops. By changing line 15's relational test, a Do Until would also work. These last two loops will not, in every case, produce less code. The logic of the application determines which loop works best.

###
The For Loop

Concept: The For loop (sometimes called the For-Next loop) also creates a loop. Unlike the Do loops, however, the For loop repeats for a specified number of times. The format of the For loop looks a little more daunting than the Do loops, but after you master the format, you'll have little trouble implementing For loops when your code needs to repeat a section of code for a specified number of times.

There isn't one correct loop to use in all situations. The For statement provides the mechanism for the fifth Visual Basic loop construction that you'll learn. A For loop always begins with the For statement and ends with the Next statement. Here is the format of the For loop:

    For CounterVar = StartVal To EndVal [Step IncrementVal]

     Block of one or more

     Visual Basic statements

    Next CounterVar

The loop in Listing 10.4 computes the total of the numbers from 1 to 10.

Listing 10.4. Add the numbers from 1 to 10.

    1: Sum = 0

    2: For Number = 1 To 10

    3: Sum = Sum + Number

    4: Next Number

Number is the CounterVar in the For's format (line 2). The CounterVar must be a variable. 1 is the StartVal (line 2). The StartVal can be either a Number, expression, or variable. 10 is the EndVal (still in line 2). The EndVal can be either a Number, expression, or variable. There is no Step specified here. In the For statement's format, the Step IncrementVal is optional. If you don't specify a Step value, Visual Basic assumes a Step value of 1. Therefore, both of the following For statements are exactly the same:

    For Number = 1 To 10

and

    For Number = 1 To 10 Step 1

Listing 10.4's summing For loop initially assigns to the CounterVar the StartVal in line 2. Therefore, Number is assigned 1 at the top of the loop. Visual Basic then executes the body of the loop using the value of 1 for Number. With Number being equal to 1, line 3 works as follows the first time through the loop:

    Sum = Sum + 1

When Visual Basic executes the Next Number statement, Visual Basic returns to the top of the loop (the For statement), adds the Step value of 1 to Number, and continues the loop again using 2 as Number in the loop's body. Therefore, the second time through the loop, line 3 works as follows:

    Sum = Sum + 2

The loop continues, adding the default Step value of 1 to Number each time that the loop executes. When Number becomes 10 (the EndVal), the loop finishes and the statement following the Next statement continues.

> > Tip: Remember, the For loop terminates when the CounterVar becomes larger than the EndVal. There's an exception to this: If you code a negative Step value, the loop terminates when the CounterVar becomes smaller than the EndVal, as you'll see a little later in this section.

You don't need the For statement to sum the values of 1 through 10. You could code one long assignment statement like this:

    Sum = 1 + 2 + 3 +
    4 + 5 + 6 + 7 + 8 + 9 + 10

You could also code back-to-back assignment statements like this:

    Sum = Sum + 1

    Sum = Sum + 2

    Sum = Sum + 3

    Sum = Sum + 4

    Sum = Sum + 5

    Sum = Sum + 6

    Sum = Sum + 7

    Sum =
    Sum + 8

    Sum = Sum + 9

    Sum = Sum + 10

Neither of these approaches is extremely difficult, but what if you needed to add together the first one hundred integer Numbers? The previous assignments could become tedious indeed, but the For loop to add the first one hundred integers is just as easy to code as for the first 10 integers, as Listing 10.5 demonstrates.

Listing 10.5. Add the Numbers from 1 to 100.

    1:
    Sum = 0

    2: For Number = 1 To 100 ' Only this line changes

    3: Sum = Sum + Number

    4: Next Number

The following loop displays five message boxes:

    For c = 1 To 20 Step 4

     MsgBox "This is a message
    box"

    Next c

> > Definition: A loop iteration is one full loop cycle.

The loop counts up from 1 to 20 by 4s, putting each count into the variable named c and printing a message box each time. The Step value changes how Visual Basic updates the CounterVar each time that the loop iterates.

If you specify a negative Step value, Visual Basic counts down. The following loop rings the PC's speaker five times:

    For i = 5 To 1 Step -1

     Beep

    Next i

> > Warning: If you specify a negative Step value, the EndVal must be less than the StartVal or Visual Basic will execute the loop only once.

> > You Can Terminate Loops Early: Sometimes, you'll be processing user input or several data values using looping statements, and an exception occurs in the data that requires an immediate termination of the loop. For example, you may be collecting sales values for a company's ten divisions inside a For loop that iterates ten times. However, the user can enter zero for a division's sales value, indicating that there is no sales data for that division. Rather than complete the loop, your program might need to quit the loop at that point because the full divisional report information can't be gathered at the time.
> > The Exit Do and the Exit For statements automatically terminate loops. No matter what the Do loop's relational test results in, or no matter how many more iterations are left in a For loop, when Visual Basic encounters an Exit Do or Exit For statement, Visual Basic immediately quits the loop and sends execution down to the statement following the loop.
> > Typically, an If statement triggers one of the Exit statements like this:
> > For Divisions = 1 To 10
> > ' Code to get a sales value
> > If (sales = 0) Then
> > Exit For ' Quit the loop early
> > End If
> > ' Process the rest of the code
> > Next Divisions
> > The If ensures that the Exit For executes only under one specific condition (a missing sales value). Without that specific condition triggering the Exit For, the loop cycles normally.

Stop and Type: Listing 10.6 contains a fairly comprehensive For loop that computes compound interest for an initial investment of $1,000.00. The code appears inside the Click event procedure for a command button named cmdInt. In case you're not familiar with compound interest, each year the amount of money invested, including interest earned so far, compounds to build more money. Each time period, normally a year, means that another year's interest must be added to the value of the investment. A For loop is perfect for calculating interest. Listing 10.6 uses five compound cycles.

Review: The For loop repeats a block of one or more statements of Visual Basic code. Unlike the Do loops, the For loop iterates for a specified Number of times as controlled by the For statement's control values and variables.

Listing 10.6. Using a For loop to calculate compound interest.

    1: Sub cmdInt_Click ()

    2: ' Use a For loop to calculate a final total

    3: ' investment using compound interest.

    4: ' Num is a loop control variable

    5: ' IRate is the annual interest rate

    6: ' Term is the Number of years in the
    investment

    7: ' InitInv is the investor's initial investment

    8: ' Interest is the total interest paid

    9: Dim IRate, Interest As Single

    10: Dim Term, Num As Integer

    11: Dim InitInv As Currency

    12:

    13: IRate = .08

    14: Term = 5

    15: InitInv = 1000.00

    16: Interest = 1 ' Begin at one for first compound

    17:

    18: ' Use loop to calculate total compound amount

    19: For Num = 1 To Term

    20: Interest = Interest * (1 + IRate)

    21: Next

    22:

    23: ' Now we have total interest,

    24: ' calculate the total
    investment

    25: ' at the end of N years

    26: lblFinalInv.Caption = InitInv * Interest

    27: End Sub

Analysis: This analysis focuses on the loop and not the interest calculation. The most important thing that you can do at this point is to master the For looping statement. Lines 1 through 8 contain fairly extensive remarks. The remarks contain variable descriptions so that anyone looking at the code or changing the code later will know what the variables are for.

After the program defines all the variables in lines 9 through 11, the variables are initialized with start-up values in lines 13 through 16. If you use this event procedure, be sure to add a label named lblFinalInv to a form and add a command button to the form named cmdInt. Line 15 will seem to give you trouble as you type it unless you remember Lesson 2's description of data suffix characters. Visual Basic uses the pound sign, #, to indicate double-precision values, and Visual Basic will assume that 1000.00 is a double-precision value (I don't know why) and will convert the 1000.00 to 1000# right after you press Enter at the end of the line! Don't worry about Visual Basic's pickiness here.

The most important part of this program appears on lines 19 through 21. Line 19 begins a For loop that iterates through each interest rate period (five of them), compounding the interest on top of the investment to date on line 20. Again, don't let the finance worry you. The calculation is less important than understanding the looping process. After the loop finishes, line 26 completes the event procedure by placing the compounded investment in the label. By the way, if you do implement this event procedure in your own application, the investment will appear in the window as a double-precision Number with several decimal places showing. You'll learn how to format the data into dollars and cents in lesson 7.

###
Homework

####
General Knowledge

1. What is a loop?
2. How many different kinds of looping statements does Visual Basic support?
3. How many different Do statements does Visual Basic support?
4. True or false: A block can consist of a single statement.
5. What is an infinite loop?
6. How can you utilize a loop for correcting user errors?
7. How many times does the following loop execute?
   I = 10
   Do While I > 1
   I = I - 1
   Loop
8. How many times does the following loop execute?
   I = 10
   Do While I >= 1
   I = I - 1
   Loop
9. How many times does the following loop execute?
   I = 10
   Do Until I > 1
   I = I - 1
   Loop
10. How many times does the following loop execute?
    For I = 1 To 10
    Beep
    Loop
11. What Step value does Visual Basic assume if you don't specify any Step value?
12. Which statement, the Do or For statement, supports a loop that continues for a specified Number of times?
13. Which statement, the Do or For statement, supports a loop that continues according the a relational test?
14. What is the difference between a Do While and a Do Until loop?
15. What is the difference between a Do While and a Do-Loop While loop?
16. What is an iteration?
17. How can you force a For loop to count down rather than up?
18. If a For loop's initial starting value is greater than the ending value, what must be true for the increment value?
19. What statements terminate Do and For loops early?

####
Write Code That...

1. Write a program that assigns the value of 34 to a variable and then asks the user to guess the Number using an input box. Use a Do loop to check the user's guess and keep asking for additional guesses until the user guesses the Number.

####
Find the Bug

1. Larry, a fledgling programmer, wrote the following For loop that seems to be in an infinite loop. Can you spot the problem?
   For i = 1 To 25
   Total = Total * I
   i = i - 1
   Next i
2. Kim wants her For loop to loop for 100 iterations but she's having trouble. Tell Kim what's wrong with the following attempt:
   For I = 100 To 1 Step 1

####
Extra Credit

A nested loop is a loop within a loop. The outer loop determines how many times the inner loop executes. See whether you can determine how many times the following code beeps the user.
For i = 1 To 5 ' The outer loop
For j = 1 To 3 ' The inner loop
Beep
Next j ' Inner loop completes before
Next i ' outer loop iterates again