Introduction to Problem Solving and Control Statements in Visual Basic 2010

This chapter is from the book

Visual Basic 2010 How to Program, 5th Edition

Learn More Buy

This chapter is from the book

This chapter is from the book 

Visual Basic 2010 How to Program, 5th Edition

Learn More Buy

Summary

Section 4.2 Algorithms

• Computing problems are solved by executing actions in a specific order.
• An algorithm is a procedure for solving a problem in terms of the actions to be executed and the order in which these actions are to be executed.
• Program control refers to the task of ordering a program's statements correctly.

Section 4.3 Pseudocode

• Pseudocode is an informal language that helps you develop algorithms and "think out" a program before attempting to write it in a programming language.
• Carefully prepared pseudocode can be converted easily to a corresponding Visual Basic program.

Section 4.4 Control Structures

• Normally, statements in a program execute sequentially in the order in which they're written.
• Various Visual Basic statements enable you to specify that the next statement to be executed might not be the next one in sequence. This is called a transfer of control.
• All programs can be written in terms of the sequence, selection and repetition structures.
• The sequence structure is built into Visual Basic. Unless directed otherwise, the computer executes Visual Basic statements one after the other in the order in which they're written.
• A UML activity diagram models the workflow (also called the activity) of a software system.
• Like pseudocode, activity diagrams help you develop and represent algorithms.
• An action state is represented as a rectangle with its left and right sides replaced by arcs curving outward. An action expression appears inside the action state.
• The arrows in an activity diagram represent transitions that indicate the order in which the actions represented by action states occur.
• The solid circle in an activity diagram represents the initial state—the beginning of the workflow before the program performs the modeled actions.
• The solid circle surrounded by a hollow circle in an activity diagram represents the final state—the end of the workflow after the program performs its actions.
• UML notes are optional explanatory remarks that describe the purpose of symbols in the diagram. A dotted line connects each note with the element that it describes.
• Single-entry/single-exit control statements make it easy to build programs.
• In control-statement stacking, the control statements are attached to one another by connecting the exit point of one control statement to the entry point of the next.
• In control-statement nesting, one control statement is placed inside another.
• The If...Then single-selection statement selects or ignores an action (or group of actions) based on the truth or falsity of a condition.
• The If...Then...Else double-selection statement selects between two different actions (or groups of actions) based on the truth or falsity of a condition.
• A multiple-selection statement selects among many different actions or groups of actions.
• The Do While...Loop and While...End While repetition statements execute a set of statements while a loop-continuation condition remains true. If the condition is initially false, the set of statements does not execute.
• The Do Until...Loop repetition statement executes a set of statements until a loop-termination condition becomes true. If the condition is initially true, the set of statements does not execute.
• The Do...Loop While repetition statement executes a set of statements while its loop-continuation condition remains true. The set of statements is guaranteed to execute at least once.
• The Do...Loop Until repetition statement executes a set of statements until a loop-termination condition becomes true. The set of statements is guaranteed to execute at least once.
• The For...Next repetition statement executes a set of statements a specified number of times.
• The For Each...Next repetition statement performs a set of statements for every element of a an array or collection of values.

Section 4.5 If...Then Selection Statement

• Syntax errors are caught by the compiler. Logic errors affect the program only at execution time. Fatal logic errors cause a program to fail and terminate prematurely. Nonfatal logic errors do not terminate a program's execution but cause the program to produce incorrect results.
• The diamond or decision symbol in an activity diagram indicates that a decision is to be made. A decision symbol indicates that the workflow will continue along a path determined by the symbol's associated guard conditions, which can be true or false.
• Each transition arrow emerging from a decision symbol has a guard condition (specified in square brackets above or next to the transition arrow). If a particular guard condition is true, the workflow enters the action state to which that transition arrow points.

Section 4.6 If...Then...Else Selection Statement

• The If...Then...Else selection statement allows you to specify that a different action (or sequence of actions) is to be performed when the condition is true than when the condition is false.

Section 4.7 Nested If...Then...Else Selection Statements

• Nested If...Then...Else statements test for multiple conditions by placing If...Then...Else statements inside other If...Then...Else statements.
• Keyword ElseIf can be used in nested If...Then...Else statements to make them more readable.

Section 4.8 Repetition Statements

• The UML's merge symbol joins two flows of activity into one flow of activity. The UML represents both the merge symbol and the decision symbol as diamonds.
• The Do While...Loop repetition statement allows you to specify that an action is to be repeated while a specific condition remains true.
• Eventually, the loop-continuation condition in a Do While...Loop statement becomes false. At this point, the repetition terminates, and continues with the next statement in sequence.
• Failure to provide the body of a Do While...Loop statement with an action that eventually causes the loop-continuation condition to become false is a logic error. Normally, such a repetition statement never terminates, resulting in an error called an "infinite loop."
• The While...End While repetition statement operates identically to Do While...Loop.
• Statements in the body of a Do Until...Loop are executed repeatedly as long as the loop-termination condition evaluates to false.

Section 4.9 Compound Assignment Operators

• Visual Basic provides the compound assignment operators +=, -=, *=, /=, \=, ^= and &= for abbreviating assignment statements.

Section 4.10 Formulating Algorithms: Counter-Controlled Repetition

• Many algorithms can be divided logically into an initialization phase, a processing phase and a termination phase.
• The ListBox control can be used to display a list of values that your program manipulates.
• A Form's default Button is the one that will be pressed when the user presses the Enter key and is specified by setting the Form's AcceptButton property to the appropriate Button.
• Counter-controlled repetition uses a variable called a counter (or control variable) to specify the number of times that a set of statements will execute. Counter-controlled repetition also is called definite repetition because the number of repetitions is known before the loop begins executing.
• Variables used as totals and counters should be initialized before they're used. Counters usually are initialized to 0 or 1, depending on their use. Totals generally are initialized to 0.
• Numeric variables are initialized to 0 when they're declared, unless another value is assigned to the variable in its declaration.
• A ListBox's Items property keeps track of the values in the ListBox. To place a new item in a ListBox, call the Items property's Add method.
• Calling a control's Focus method makes the control the active control—the one that will respond to the user's interactions.
• Type Double is typically used to store floating-point numbers. Floating-point literals in a program's source code are treated as Double values by default.
• Local variables can be used only from their declaration until the end of the method declaration. A local variable's declaration must appear before the variable is used in that method.
• ListBox property Items.Count keeps track of the ListBox's number of items.
• Each value in a ListBox has a position number associated with it—this is known the item's index.
• For a ListBox, calling the Item's property's Clear method removes all the items in the ListBox.
• Formatted output allows you to control how a number appears for display purposes. The String class's Format method performs formatting.
• In the format string "{0:F}", the numeric value that appears before the colon indicates which of Format's arguments will be formatted—0 specifies the first argument after the format string passed to Format. The F is as a format specifier which indicates that a fixed-point number should be rounded to two decimal places by default.

Section 4.11 Formulating Algorithms: Nested Control Statements

• Control statements can be stacked or nested within one another.
• Top-down, stepwise refinement is a technique for developing algorithms.
• The top is a single statement that conveys the overall function of the program. As such, the top is a complete representation of a program.
• Through the process of refinement, we divide the top into a series of smaller tasks, listed in the order in which they must be performed. Each refinement, including the top, is a complete specification of the algorithm; only the level of detail in each refinement varies.
• You terminate the top-down, stepwise refinement process when the pseudocode algorithm is specified in sufficient detail for the pseudocode to be converted to a Visual Basic program.

Section 4.12 Using the Debugger: Locating a Logic Error

• Logic errors are also called bugs. Such errors do not prevent a program from compiling successfully, but can cause a running program to produce incorrect results.
• Visual Studio's debugger can be used to monitor the execution of your programs so you can locate and remove logic errors.
• An off-by-one error is often caused by using the incorrect relational operator in a loop condition.
• Breakpoints can be set at any executable line of code.
• Once the debugger pauses program execution, you can use various debugger commands to execute the program one statement at a time—this is called "single stepping" or simply "stepping."
• To insert a breakpoint, left click in the margin indicator bar or select Breakpoint > Insert Breakpoint. You can also click a line of code then press F9 to toggle a breakpoint on and off.
• After setting breakpoints in the code editor, select Debug > Start Debugging (or press the F5 key) to rebuild the program and begin the debugging process.
• When the debugger reaches a breakpoint, it suspends execution and enters break mode. A yellow instruction-pointer arrow in the IDE indicates the next statement to execute.
• While in break mode, you can place the mouse cursor over any variable and its value will be displayed in a Quick Info box. You can also explore the values of a method's local variables using the debugger's Locals window. To view the Locals window, select Debug > Windows > Locals.
• To execute a program one statement at a time, use the Step Over command. You can access this command by selecting Debug > Step Over, by pressing Shift + F8 or by pressing the Step Over command's toolbar icon ().