ICT role in 21st century education and its challenges
05 control structures 2
1. Chapter 5 – Control Structures: Part 2 Outline 5.1 Introduction 5.2 Essentials of Counter-Controlled Repetition 5.3 For / Next Repetition Structure 5.4 Examples Using the For / Next Structure 5.5 Select Case Multiple-Selection Structure 5.6 Do / Loop While Repetition Structure 5.7 Do / Loop Until Repetition Structure 5.8 Using the Exit Keyword in a Repetition Structure 5.9 Logical Operators 5.10 Structured Programming Summary
2.
3.
4. WhileCounter.vb 1 ' Fig. 5.1: WhileCounter.vb 2 ' Using the While structure to demonstrate counter-controlled 3 ' repetition. 4 5 Module modWhileCounter 6 7 Sub Main() 8 9 Dim counter As Integer = 2 ' initialization 10 11 While (counter <= 10 ) ' repetition condition 12 Console.Write(counter & " ") 13 counter += 2 ' increment counter 14 End While 15 16 End Sub ' Main 17 18 End Module ' modWhileCounter 2 4 6 8 10 While structure used for repetition Control variable defined and initialized to 2 Control variable incremented by 2 each iteration Condition tests if control variable is less than or equal to final value
5.
6. 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 To specifies final value of 10 Step increments counter by 2 each iteration Next marks end of loop
7. 5.3 For / Next Repetition Structure Fig. 5.3 Components 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
8.
9. 5.4 Examples Using the For / Next Structure Fig. 5.4 Flowcharting a typical For/Next repetition structure. counter = 1 counter < = 10 (implicit) false true Console.WriteLine(counter * 10) counter += 1 (implicit) Establish initial value of control variable Determine if final value of control variable has been reached Body of loop (this can be multiple statements) Increment the control variable
10. Sum.vb Program Output 1 ' Fig. 5.5: Sum.vb 2 ' Using For/Next structure to demonstrate summation. 3 4 Imports System.Windows.Forms 5 6 Module modSum 7 8 Sub Main() 9 10 Dim sum = 0 , number As Integer 11 12 ' add even numbers from 2 to 100 13 For number = 2 To 100 Step 2 14 sum += number 15 Next 16 17 MessageBox.Show( "The sum is " & sum, _ 18 "Sum even integers from 2 to 100" , _ 19 MessageBoxButtons. OK , MessageBoxIcon. Information ) 20 End Sub ' Main 21 22 End Module ' modSum Control variable counts by 2, from 2 to 100 Value of number is added in each iteration to determine sum of even numbers Text displayed in dialog Display a MessageBox Indicate button to be OK button Indicate icon to be Information icon Text displayed in title bar
11. 5.4 Examples Using the For / Next Structure Fig. 5.6 Icons for message dialogs.
12. 5.4 Examples Using the For / Next Structure Fig. 5.7 Button constants for message dialogs.
13. Interest.vb 1 ' Fig. 5.8: Interest.vb 2 ' Calculating compound interest. 3 4 Imports System.Windows.Forms 5 6 Module modInterest 7 8 Sub Main() 9 10 Dim amount, principal As Decimal ' dollar amounts 11 Dim rate As Double ' interest rate 12 Dim year As Integer ' year counter 13 Dim output As String ' amount after each year 14 15 principal = 1000.00 16 rate = 0.05 17 18 output = "Year" & vbTab & "Amount on deposit" & vbCrLf 19 20 ' calculate amount after each year 21 For year = 1 To 10 22 amount = principal * ( 1 + rate) ^ year 23 output &= year & vbTab & _ 24 String.Format( "{0:C}" , amount) & vbCrLf 25 Next 26 27 ' display output 28 MessageBox.Show(output, "Compound Interest" , _ 29 MessageBoxButtons. Ok , MessageBoxIcon. Information ) 30 31 End Sub ' Main 32 33 End Module ' modInterest Perform calculation to determine amount in account Append year followed by the formatted calculation result and newline character to end of String output Specify C (for “currency”) as formatting code Type Decimal used for precise monetary calculations
15. 5.4 Examples Using the For / Next Structure Fig. 5.9 String formatting codes.
16.
17. SelectTest.vb 1 ' Fig. 5.10: SelectTest.vb 2 ' Using the Select Case structure. 3 4 Module modEnterGrades 5 6 Sub Main() 7 Dim grade As Integer = 0 ' one grade 8 Dim aCount As Integer = 0 ' number of As 9 Dim bCount As Integer = 0 ' number of Bs 10 Dim cCount As Integer = 0 ' number of Cs 11 Dim dCount As Integer = 0 ' number of Ds 12 Dim fCount As Integer = 0 ' number of Fs 13 14 Console.Write( "Enter a grade, -1 to quit: " ) 15 grade = Console.ReadLine() 16 17 ' input and process grades 18 While grade <> -1 19 20 Select Case grade ' check which grade was input 21 22 Case 100 ' student scored 100 23 Console.WriteLine( "Perfect Score!" & vbCrLf & _ 24 "Letter grade: A" & vbCrLf ) 25 aCount += 1 26 27 Case 90 To 99 ' student scored 90-99 28 Console.WriteLine( "Letter Grade: A" & vbCrLf ) 29 aCount += 1 30 31 Case 80 To 89 ' student scored 80-89 32 Console.WriteLine( "Letter Grade: B" & vbCrLf ) 33 bCount += 1 34 Select Case begins multiple-selection structure Controlling expression First Case executes if grade is exactly 100 Next Case executes if grade is between 90 and 99, the range being specified with the To keyword
18. SelectTest.vb 35 Case 70 To 79 ' student scored 70-79 36 Console.WriteLine( "Letter Grade: C" & vbCrLf ) 37 cCount += 1 38 39 Case 60 To 69 ' student scored 60-69 40 Console.WriteLine( "Letter Grade: D" & vbCrLf ) 41 dCount += 1 42 43 ' student scored 0 or 10-59 (10 points for attendance) 44 Case 0 , 10 To 59 45 Console.WriteLine( "Letter Grade: F" & vbCrLf ) 46 fCount += 1 47 48 Case Else 49 50 ' alert user that invalid grade was entered 51 Console.WriteLine( "Invalid Input. " & _ 52 "Please enter a valid grade." & vbCrLf ) 53 End Select 54 55 Console.Write( "Enter a grade, -1 to quit: " ) 56 grade = Console.ReadLine() 57 End While 58 59 ' display count of each letter grade 60 Console.WriteLine( vbCrLf & _ 61 "Totals for each letter grade are: " & vbCrLf & _ 62 "A: " & aCount & vbCrLf & "B: " & bCount _ 63 & vbCrLf & "C: " & cCount & vbCrLf & "D: " & _ 64 dCount & vbCrLf & "F: " & fCount) 65 66 End Sub ' Main 67 68 End Module ' modEnterGrades Optional Case Else executes if no match occurs with previous Case s End Select marks end of structure
19. Program Output Enter a grade: 84 Letter Grade: B Enter a grade: 100 Perfect Score! Letter grade : A+ Enter a grade: 7 Invalid Input. Please enter a valid grade. Enter a grade: 95 Letter Grade: A Enter a grade: 78 Letter Grade: C Totals for each letter grade are: A: 2 B: 1 C: 1 D: 0 F: 0
20. 5.5 Select Case Multiple Fig. 5.11 Flowcharting the Select Case multiple-selection structure. Case a Case b Case z . . . Case Else action(s) false false false Case a action(s) Case b action(s) Case z action(s) true true true
21.
22. DoWhile.vb Program Output 1 ' Fig. 5.12: DoWhile.vb 2 ' Demonstrating the Do/Loop While repetition structure. 3 4 Module modDoWhile 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 While (counter <= 5 ) 15 16 End Sub ' Main 17 18 End Module ' modDoWhile 1 2 3 4 5 Do keyword begins structure Loop While ends structure Condition tested after body executes
23. 5.7 Do / Loop Until Repetition Structure Fig. 5.13 Flowcharting the Do/Loop While repetition structure. true false action(s) condition
24.
25. LoopUntil.vb Program Output 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 6 7 8 9 Condition tested after body executes
26. 5.7 Do / Loop Until Repetition Structure Fig. 5.15 Flowcharting the Do/Loop Until repetition structure. true false action(s) condition
27.
28. ExitTest.vb 1 ' Fig. 5.16: ExitTest.vb 2 ' Using the Exit keyword in repetition structures. 3 4 Imports System.Windows.Forms 5 6 Module modExitTest 7 8 Sub Main() 9 Dim output As String 10 Dim counter As Integer 11 12 For counter = 1 To 10 13 14 ' skip remaining code in loop only if counter = 3 15 If counter = 3 Then 16 Exit For 17 End If 18 19 Next 20 21 output = "counter = " & counter & _ 22 " after exiting For/Next structure" & vbCrLf 23 24 Do Until counter > 10 25 26 ' skip remaining code in loop only if counter = 5 27 If counter = 5 Then 28 Exit Do 29 End If 30 31 counter += 1 32 Loop 33 Loop specified to execute 10 times Exit For statement executes when condition is met, causing loop to exit Program control proceeds to first statement after the structure counter is 3 when loop starts, specified to execute until it is greater than 10 Exit Do executes when counter is 5, causing loop to exit
29. Program Output 34 output &= "counter = " & counter & _ 35 " after exiting Do Until/Loop structure" & vbCrLf 36 37 While counter <= 10 38 39 ' skip remaining code in loop only if counter = 7 40 If counter = 7 Then 41 Exit While 42 End If 43 44 counter += 1 45 End While 46 47 output &= "counter = " & counter & _ 48 " after exiting While structure" 49 50 MessageBox.Show(output, "Exit Test" , _ 51 MessageBoxButtons. OK , MessageBoxIcon. Information ) 52 End Sub ' Main 53 54 End Module ' modExitTest counter is 5 when loop starts, specified to execute while less than or equal to 10 Exit While executes when counter is 7, causing loop to exit
35. 5.9 Logical Operators Fig. 5.19 Truth table for the boolean logical exclusive OR (Xor) operator. Fig. 5.20 Truth table for operator Not (logical NOT).
39. 5.9 Logical Operators Fig. 5.22 Precedence and associativity of the operators discussed so far.
40.
41. 5.10 Structured Programming Summary Fig. 5.23 Visual 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)
42. 5.10 Structured Programming Summary Fig. 5.24 Visual 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
43. 5.10 Structured Programming Summary Fig. 5.24 Visual 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
46. 5.10 Structured Programming Summary Fig. 5.28 Applying rule 3 of Fig. 5.25 to the simplest flowchart. Rule 3 Rule 3
47. 5.10 Structured Programming Summary Fig. 5.29 Stacked, nested and overlapped building blocks. Nested building blocks Stacked building blocks Overlapping building blocks (Illegal in structured programs)