1. Control Structures: Part 2

2. Introduction Essentials of Counter-Controlled Repetition For / Next Repetition Structure Examples Using the For / Next Structure Select Case Multiple-Selection Structure Do / Loop While Repetition Structure Do / Loop Until Repetition Structure Using the Exit Keyword in a Repetition Structure Logical Operators Structured Programming Summary Outline

3. The For/Next repetition structure handles the details of counter-controlled repetition. To illustrate the power of For/Next, we now rewrite the previous program. The result is displayed in following figure: For/Next Repetition Structure

4. ForCounter.vb Program Output 1 ' Fig. 5.2: ForCounter.vb 2 ' Using the For/Next structure to demonstrate counter-controlled 3 ' repetition. 4 5 Module modForCounter 6 7 Sub Main() 8 Dim counter As Integer 9 10 ' initialization, repetition condition and 11 ' incrementing are included in For structure 12 For counter = 2 To 10 Step 2 13 Console.Write(counter & " ") 14 Next 15 16 End Sub ' Main 17 18 End Module ' modForCounter 2 4 6 8 10 Control variable initialized to 2 Step increments counter by 2 each iteration Next marks end of loop

5. For / Next Repetition Structure For / Next counter-controlled repetition – Structure header initializes control variable, specifies final value and increment For keyword begins structure – Followed by control variable initialization To keyword specifies final value Step keyword specifies increment – Optional, Increment defaults to 1 if omitted – May be positive or negative Next keyword marks end of structure – Executes until control variable greater (or less) than final value

6. For / Next Repetition Structure Fig. 5.3Components of a typical For/Next header. For counter = 2 To 10 Step 2 For keyword Initial value of control variable Final value of control variable Increment of control variable Control variable name To keyword Step keyword

7. Examples Using the For / Next Structure – Vary the control variable from 1 to 100 in increments of 1 For i = 1 To 100 For i = 1 To 100 Step 1 – Vary the control variable from 100 to 1 in increments of –1 For i = 100 To 1 Step – 1 – Vary the control variable from 7 to 77 in increments of 7 For i = 7 To 77 Step 7 – Vary the control variable from 20 to 2 in increments of –2 For i = 20 To 2 Step -2 – Vary the control variable over the sequence of the following values: 2, 5, 8, 11,14, 17, 20. For i = 2 To 20 Step 3 – Vary the control variable over the sequence of the following values: 99, 88, 77,66, 55, 44, 33, 22, 11, 0. For i = 99 To 0 Step -11

8. Program to sum the even integers from 2 to 100.

9. Examples Using the For / Next Structure Fig. 5.6Icons for message dialogs.

10. Fig. 5.7Button constants for message dialogs. Examples Using the For / Next Structure

11. The next example computes compound interest using the For/Next structure. Consider the following problem statement: The next example computes compound interest using the For/Next structure. Consider the following problem statement: A person invests $1000.00 in a savings account that yields 5% interest. Assuming that all interest is left on deposit, calculate and print the amount of money in the account at the end of each year over a period of 10 years. To determine these amounts, use the following formula: A person invests $1000.00 in a savings account that yields 5% interest. Assuming that all interest is left on deposit, calculate and print the amount of money in the account at the end of each year over a period of 10 years. To determine these amounts, use the following formula: a = p (1 + r) n where where p is the original amount invested (i.e., the principal) r is the annual interest rate (e.g.,.05 stands for 5%) n is the number of years a is the amount on deposit at the end of the nth year. Examples Using the For / Next Structure

12. Type Decimal used for precise monetary calculations Specify C (for “currency”) as formatting code a tab character (vbTab) to position to the second column. Newline character (vbCrLf) to start the next output on the next line.

13. Program Output

14. Fig. 5.9String formatting codes. Examples Using the For / Next Structure

15. Select Case Multiple-Selection Structure Multiple-Selection Structure – Tests expression separately for each value expression may assume – Select Case keywords begin structure Followed by controlling expression – Compared sequentially with each case – Code in case executes if match is found – Program control proceeds to first statement after structure Case keyword – Specifies each value to test for – Followed by code to execute if test is true – Case Else » Optional » Executes if no match is found » Must be last case in sequence – End Select is required and marks end of structure

16. The following program is using a Select Case to count the number of different letter grades on an exam. Assume the exam is graded as follows: 90 and above is an A, 80–89 is a B, 70–79 is a C, 60–69 is a D and 0–59 is an F. This instructor gives a minimum grade of 10 for students who were present for the exam. Students not present for the exam receive a 0. Select Case Multiple-Selection Structure

18. Either 0 or any value in the range 10 to 59, inclusive matches this Case. Optional Case Else executes if no match occurs with previous Case s Required End Select marks end of structure

19. Program Output

20. Case statements also can use relational operators to determine whether the controlling expression satisfies a condition. For example: Case Is < 0 uses keyword Is along with the relational operator, <, to test for values less than 0. Best control to use with is the ComboBox. Select Case Multiple-Selection Structure

21. Fig. 5.11Flowcharting the Select Case multiple-selection structure. Case a Case b Case z...... Case Else action(s) false Case a action(s) Case b action(s) Case z action(s) true Select Case Multiple-Selection Structure

22. Do / Loop While Repetition Structure – Similar to While and Do / While – Loop-continuation condition tested after body executes Loop body always executed at least once – Begins with keyword Do – Ends with keywords Loop While followed by condition

23. Do / Loop While Repetition Structure

24. Fig. 5.13Flowcharting the Do/Loop While repetition structure. true false condition action(s) Do / Loop While Repetition Structure

25. Do / Loop Until Repetition Structure – Similar to Do Until / Loop structure – Loop-continuation condition tested after body executes Loop body always executed at least once

26. 1 ' Fig. 5.14: LoopUntil.vb 2 ' Using Do/Loop Until repetition structure 3 4 Module modLoopUntil 5 6 Sub Main() 7 8 Dim counter As Integer = 1 9 10 ' print values 1 to 5 11 Do 12 Console.Write(counter & " ") 13 counter += 1 14 Loop Until counter > 5 15 16 End Sub ' Main 17 18 End Module ' modLoopUntil 1 2 3 4 5 Condition tested after body executes Print the numbers from 1–5.

27. Fig. 5.15Flowcharting the Do/Loop Until repetition structure. true false condition action(s) Do / Loop Until Repetition Structure

28. Using the Exit Keyword in a Repetition Structure Exit Statements: – Alter the flow of control: Cause immediate exit from a repetition structure – Exit Do Executed in Do While/Loop, Do/Loop While, Do Until/Loop or Do/Loop Until structures. – Exit For Executed in For structures – Exit While Executed in While structures

29. counter is 3 when loop starts, specified to execute until it is greater than 10

31. Program Output

32. To handle multiple conditions more efficiently, Visual Basic provides logical operators that can be used to form complex conditions by combining simple ones. The logical operators are AndAlso, And, OrElse, Or, Xor and Not. We consider examples that use each of these operators. Logical Operators

33. 1. Logical operator with short-circuit evaluation: Execute only until truth or falsity is known: AndAlso operator – Returns true if and only if both conditions are true OrElse operator – Returns true if either or both of two conditions are true

34. 2. Logical Operators without short-circuit evaluation: – And and Or Similar to AndAlso and OrElse respectively Always execute both of their operands Used when an operand has a side effect – Condition makes a modification to a variable – Should be avoided to reduce subtle errors – Xor Returns true if and only if one operand is true and the other false Logical Operators

35. Normally, there is no compelling reason to use the And and Or operators instead of AndAlso and OrElse. However, some programmers make use of them when the right operand of a condition produces a side effect (such as a modification of a variable’s value) or if the right operand includes a required method call, as in the following program segment: Console.WriteLine("How old are you?") If (gender = "F" And Console.ReadLine() >= 65) Then Console.WriteLine("You are a female senior citizen.") End If Here, the And operator guarantees that the condition Console.ReadLine() >= 65 is evaluated, so ReadLine is called regardless of whether the overall expression is true or false. It would be better to write this code as two separate statements—the first would store the result of Console.ReadLine() in a variable, then the second would use that variable with the AndAlso operator in the condition. Logical Operators

36. Logical Negation – Not Used to reverse the meaning of a condition Unary operator – Requires one operand Can usually be avoided by expressing a condition differently

37. Logical Operators Fig. 5.17Truth table for the AndAlso (logical AND) operator.

38. Logical Operators Fig. 5.18Truth table for the OrElse (logical OR) operator.

39. Logical Operators Fig. 5.19Truth table for the boolean logical exclusive OR (Xor) operator. Fig. 5.20Truth table for operator Not (logical NOT).

42. Program Output

43. Logical Operators Fig. 5.22Precedence and associativity of the operators discussed so far.

44. Structured Programming Summary Structured Programming – Promotes simplicity – Produces programs that are easier to understand, test, debug and modify – Rules for Forming Structured Programs If followed, an unstructured flowchart cannot be created – Only three forms of control needed Sequence Selection – If / Then structure sufficient to provide any form of selection Repetition – While structure sufficient to provide any form of repetition

45. Structured Programming Summary Fig. 5.23Visual Basic’s single-entry/single-exit sequence and selection structures. Sequence... Selection If / Then structure (single selection) T F If / Then / Else structure (double selection) T F... Select Case structure (multiple selection)

46. Structured Programming Summary Fig. 5.24Visual Basic’s single-entry/single-exit repetition structures. While structure T F F T For / Next structure T F Do / Loop Until structure Do / Loop While structure F T Repetition

47. Structured Programming Summary Fig. 5.24Visual Basic’s single-entry/single-exit repetition structures. Do While / Loop structure T F Do Until / Loop structure F T F T For Each / Next structure Repetition

48. Conclusion The For/Next repetition structure handles the details of counter-controlled repetition. The required To keyword specifies the initial value and the final value of the control variable. The optional Step keyword specifies the increment. The For/Next repetition structure handles the details of counter-controlled repetition. The required To keyword specifies the initial value and the final value of the control variable. The optional Step keyword specifies the increment. When supplying four arguments to method MessageBox.Show, the first two arguments are strings displayed in the dialog and the dialog’s title bar. The third and fourth arguments are constants representing buttons and icons, respectively. When supplying four arguments to method MessageBox.Show, the first two arguments are strings displayed in the dialog and the dialog’s title bar. The third and fourth arguments are constants representing buttons and icons, respectively.

49. Visual Basic provides the Select Case multiple- selection structure to test a variable or expression separately for each value that the variable or expression might assume. The Select Case structure consists of a series of Case labels and an optional Case Else. Each Case contains statements to be executed if that Case is selected. Visual Basic provides the Select Case multiple- selection structure to test a variable or expression separately for each value that the variable or expression might assume. The Select Case structure consists of a series of Case labels and an optional Case Else. Each Case contains statements to be executed if that Case is selected.Conclusion

50. The logical operators are AndAlso (logical AND with short-circuit evaluation), And (logical AND without short-circuit evaluation), OrElse (logical inclusive OR with short-circuit evaluation), Or (logical inclusive OR without short-circuit evaluation), Xor (logical exclusive OR) and Not (logical NOT, also called logical negation).Conclusion