1 / 36

Chapter 5 – Control Structures: Part 2

Chapter 5 – Control Structures: Part 2.

wyolanda
Télécharger la présentation

Chapter 5 – Control Structures: Part 2

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 5 – Control Structures: Part 2 Outline5.1 Introduction5.2   Essentials of Counter-Controlled Repetition5.3   For/Next Repetition Structure5.4   Examples Using the For/Next Structure5.5   SelectCase Multiple-Selection Structure5.6   Do/LoopWhile Repetition Structure5.7   Do/LoopUntil Repetition Structure5.8 Using the Exit Keyword in a Repetition Structure5.9   Logical Operators

  2. 5.2 Essentials of Counter-Controlled Repetition • Elements needed • Control variable • Used to determine whether loop continues to iterate • Initial value of control variable • Increment (or decrement) • Describes how control variable is modified during each iteration • Condition • Tests for final value of control variable

  3. While structure used for repetition Condition tests if control variable is less than or equal to final value Control variable defined and initialized to 2 Control variable incremented by 2 each iteration 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 WhileCounter.vb 2 4 6 8 10

  4. 5.3 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

  5. Control variable initialized to 2 To specifies final value of 10 Step increments counter by 2 each iteration Next marks end of loop 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 = 2To10 Step 2 13 Console.Write(counter & " ") 14 Next 15 16 End Sub ' Main 17 18 End Module ' modForCounter ForCounter.vbProgram Output 2 4 6 8 10

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

  7. 5.4 Examples Using the For/Next Structure • Examples • Vary the control variable from 1 to 100 in increments of 1 • For i = 1To100 • For i = 1To100Step1 • Vary the control variable from 100 to 1 in increments of –1 • For i = 100To1Step–1 • Vary the control variable from 7 to 77 in increments of 7 • For i = 7To77Step7 • Vary the control variable from 20 to 2 in increments of –2 • For i = 20To2Step-2

  8. Establish initial value of control variable counter = 1 Determine if final value of control variable has been reached true counter < = 10 (implicit) Console.WriteLine(counter * 10) counter += 1 (implicit) Body of loop (this can be multiple statements) Increment the control variable false 5.4 Examples Using the For/Next Structure Fig. 5.4 Flowcharting a typical For/Next repetition structure.

  9. 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 Text displayed in title bar Indicate button to be OK button Indicate icon to be Information icon 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 = 2To100 Step2 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 Sum.vbProgram Output

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

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

  12. Type Decimal used for precise monetary calculations Perform calculation to determine amount in account Append year followed by the formatted calculation result and newline character to end of Stringoutput Specify C (for “currency”) as formatting code 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 = 1To 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 Interest.vb

  13. Program Output

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

  15. 5.5 SelectCase 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

  16. 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 1 ' Fig. 5.10: SelectTest.vb 2 ' Using the Select Case structure. 3 4 Module modEnterGrades 5 6 Sub Main() 7 Dim grade AsInteger = 0' one grade 8 Dim aCount AsInteger = 0' number of As 9 Dim bCount AsInteger = 0' number of Bs 10 Dim cCount AsInteger = 0' number of Cs 11 Dim dCount AsInteger = 0' number of Ds 12 Dim fCount AsInteger = 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 SelectCase grade ' check which grade was input 21 22 Case100 ' student scored 100 23 Console.WriteLine("Perfect Score!" & vbCrLf & _ 24 "Letter grade: A" & vbCrLf) 25 aCount += 1 26 27 Case90To99 ' student scored 90-99 28 Console.WriteLine("Letter Grade: A" & vbCrLf) 29 aCount += 1 30 31 Case80To89 ' student scored 80-89 32 Console.WriteLine("Letter Grade: B" & vbCrLf) 33 bCount += 1 34 SelectTest.vb

  17. Optional Case Else executes if no match occurs with previous Cases End Select marks end of structure 35 Case70To79 ' student scored 70-79 36 Console.WriteLine("Letter Grade: C" & vbCrLf) 37 cCount += 1 38 39 Case60To69' 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 Case0, 10To59 45 Console.WriteLine("Letter Grade: F" & vbCrLf) 46 fCount += 1 47 48 CaseElse 49 50 ' alert user that invalid grade was entered 51 Console.WriteLine("Invalid Input. " & _ 52 "Please enter a valid grade." & vbCrLf) 53 EndSelect 54 55 Console.Write("Enter a grade, -1 to quit: ") 56 grade = Console.ReadLine() 57 EndWhile 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 EndSub' Main 67 68 EndModule' modEnterGrades SelectTest.vb

  18. 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 Program Output

  19. true Casea Case a action(s) false true Caseb Case b action(s) false ... true Casez Case z action(s) false Case Elseaction(s) 5.5 SelectCase Multiple Fig. 5.11 Flowcharting the Select Case multiple-selection structure.

  20. 5.6 Do/LoopWhile Repetition Structure • 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

  21. Do keyword begins structure Loop While ends structure Condition tested after body executes 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 DoWhile.vbProgram Output 1 2 3 4 5

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

  23. 5.7 Do/LoopUntil Repetition Structure • 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

  24. Condition tested after body executes 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 AsInteger = 1 9 10 ' print values 1 to 5 11 Do 12 Console.Write(counter & " ") 13 counter += 1 14 LoopUntil counter > 5 15 16 EndSub ' Main 17 18 End Module' modLoopUntil LoopUntil.vbProgram Output 1 2 3 4 5 6 7 8 9

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

  26. 5.8 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 structures • Exit For • Executed in For structures • Exit While • Executed in While structures

  27. 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 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 AsString 10 Dim counter AsInteger 11 12 For counter = 1To10 13 14 ' skip remaining code in loop only if counter = 3 15 If counter = 3Then 16 ExitFor 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 = 5Then 28 ExitDo 29 EndIf 30 31 counter += 1 32 Loop 33 ExitTest.vb

  28. 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 34 output&="counter = "& counter & _ 35 " after exiting Do Until/Loop structure" & vbCrLf 36 37 Whilecounter <=10 38 39 ' skip remaining code in loop only if counter = 7 40 Ifcounter =7Then 41 ExitWhile 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 Program Output

  29. 5.9 Logical Operators • Used to form complex conditions by combining simple ones • 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

  30. 5.9 Logical Operators (II) • 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

  31. 5.9 Logical Operators (III) • 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

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

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

  34. 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).

  35. Program Output

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

More Related