Home > Articles > Programming > Windows Programming

  • Print
  • + Share This
This chapter is from the book


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 (transfer.jpg).
  • + Share This
  • 🔖 Save To Your Account