Visual Basic. Chapter 3

Size: px

Start display at page:

Download "Visual Basic. Chapter 3"

Carmel Newton
6 years ago
Views:

1 Visual Basic Chapter 3

2 Structured Visual Basic In this chapter, we will begin to learn how to write structured Visual Basic programs Creating a flowchart and/or creating pseudocode before you create the program ensures that you fully understand the design Makes the coding process faster and less errorprone!

3 Number-Doubling Program Recall the number-doubling program The program accepts a number as input and checks for the end of data condition. If the condition is not met, then the number is doubled, the answer is displayed and the next number is input.

4 Structured Solution Note that this program makes use of the sequence and loop structures. The correct solution primes the input and also gets the next input as the last step in the loop.

5 Starting the Program In the flowchart, the logic begins with the word start We have learned that to start a VB program, you first create a module Note that in Visual Studio, when you create a new project, the module is automatically created and named Module1 It is fine to keep the default name of Module1 If you wish to edit the module name, you will also need to make a change to the program properties. Described in Angel under Lessons->Start Here->How To s.. How to Change the Module Name on a Project in Visual Studio

6 Changing the Module Name

7 The Main Procedure The text describes adding a Main() sub procedure that is nested inside of the Module. Again, if using Visual Studio, this Sub procedure is automatically created. Sub Main is the entry point of the program and is what will execute when you run your program.

8 Compiler Options Option Explicit On This setting means that the Visual Basic compiler will enforce explicit variable declaration which means that you declare every variable before you use it On by default Option Strict On Enforces strict data typing Example, you cannot assign a variable of type Integer a value that is a Double Implicit data type conversions are restricted to only widening conversions Double can hold an Integer, but Integer cannot store a Double Off by default

9 The Program Structure The logic code we will add will go here

10 Variable Declarations In our flowchart logic, the next thing we do is to create two variables, originalnumber and calculatedanswer. We declared both as type num We are going to use whole numbers for our example, so when we create these variables in Visual Basic code, we will use the type Of Integer The green underlining is just a warning. It indicates that we have not yet used this variable.

11 Prompting the User The next step is prime the loop To prime the loop means to input the first value before the loop begins. In chapter 2 of the book, we learned how to create interactive input statements to allow the user to input data using InputBox$

12 Prompting the User We will be prompting the user by explaining what the program expects to receive as input. Recall that InputBox$ displays our message, but also inputs the user s response as a String Therefore, we will add another variable of type String to store the input

Converting to an Integer Recall that when inputting data in Visual Basic, the InputBox$ function returns a String We need to convert it to a number before we can work with it.

13 Converting to an Integer Recall that when inputting data in Visual Basic, the InputBox$ function returns a String We need to convert it to a number before we can work with it. Since we are working with whole numbers, we will use the Convert.ToInt32 method to convert the string and then assign to the Integer variable. The code is shown below. Moving forward, the screenshots only show the code inside Sub Main.

14 Checkp0int: Let s see where we are! Completed We will next need to implement the loop in Visual Basic code

15 Adding the Loop Structure In pseudocode, we created a loop with the keyword while and used keyword endwhile to indicate the end of the body of the loop. In Visual Basic we will use While and End While keywords In pseudocode, we used eof as the condition to exit the loop. Since we would like this program to be an interactive input program that ends when the user types 0 as their number, we will need to use a loop condition that checks if the user input is 0. In flowchart form, we represented the loop with a decision symbol followed by one or more actions and a flow line that bent back around to the start of the loop.

16 Adding the Loop Structure in VB End of the loop Start of the loop

17 The Loop Body Recall that the logic flow was represented by the following shapes: 1. Calculate the answer and assign to variable calculatedanswer. 2. Output calculatedanswer. 3. Input the next number and assign to variable originalnumber.

18 The Loop Body in Visual Basic The steps inside the loop are demonstrated in the next slide. The first statement does the calculation. The second statement displays the calculated result to the user. Recall that we can simplify System.Console.WriteLine to simply use Console.WriteLine when using Visual Studio. The third statement prompts the user and reads in the user s response. The last statement is necessary to convert from String input to an Integer type.

19 The Loop in Visual Basic Calcula te Display Promp Convert t& Assign

20 Checkpoint: Let s see where we are! We have completed most of the logic, we just have not accounted for the stop logic.

21 Stopping the Program In Visual Basic, the End Sub statement signifies the end of the Main() procedure and the End Module statement ends the NumberDouble module. At this point, the program is ready to be compiled and run.

22 The Complete Program

23 Running the Program Recall that in Visual Studio, you choose Build Solution to compile the program and Start Without Debugging to run it. If you directly choose Start Without Debugging, Visual Studio will automatically compile your changes for you.

24 Underscores You may encounter the underscore character (_) in some of the textbook examples and resources. The underscore is used to continue a single statement from one line to the next. It is often used for convenience if your code is scrolling too far to the right for you to conveniently see.

25 Number Doubling Program Input/Output

26 Local vs. Global Variables and Constants In Chapter 2 of the Programming Logic book, we learned about local and global variables and named constants. Local variables and local constants Declared in the procedure that uses them Available only within the procedure that declares them Global variables and global constants Declared at the program level Available to the entire program

27 Global Variables and Constants Note that it is not considered a best programming practice to use global variables, so the Visual Basic program we will look at next uses local variables as well as local constants only. Local variables and constants make a program easier to understand Global variables can be accessed and altered by any part of the program, which can make the program difficult to maintain and prone to error.

28 The Modular Program Recall from Chapter 2 that most programs consist of a main module or procedure that contains the mainline logic. The mainline logic of many procedural programs follows the structure of 1. Declarations of variables 2. Housekeeping tasks, such as displaying instructions to users, displaying report headers, opening files to read, priming the data 3. Detail loop tasks that do the main work, such as processing records and preforming calculations 4. End-of-job tasks, such as displaying totals and closing any open files

29 Payroll Report In this next section, we walk through the process of creating a Visual Basic program that implements the logic of the flowchart on the next slide. This program is a Payroll Report program that keeps looping until the user types in XXX for the name of the employee.

30 This logic will build a report that outputs Employees Names and their Gross, Deductions and Net pay. Input to the program is employee name and their gross pay. The program loops until the user types in XXX for the employee name.

31 Declaring the Variables We are familiar with how to start a program with a Module and Sub, let s move on to the variables. According to the flowchart and pseudocode, the mainline logic begins by declaring four global variables (name, gross, deduct, and net) and five global constants (RATE, QUIT, REPORT_HEADING, COLUMN_HEADING, and END_LINE).

32 Declaring the Variables The COLUMN_HEADIN G constant was not included because we have not yet learned about how to line up values in report format.

33 Declaring the Variables Recall that Dim is used to create variables and Const is used to create constants. Multiple variables of the same data type can be declared on one line as they are here or separate lines. If on the same line such as Gross, Deduct and Net, they must be commaseparated. We use Double instead of Integer because we are dealing with money and monetary values include a decimal point.

34 A Word about Words Note that in Chapter 2 of the Programming Logic book we referred to small units of code as modules. Modules could be called from the main logic. In Visual Basic, modules equates to procedures. While Visual Basic does have another level of logical groupings called Modules, the term procedure matches to the concept of what was described to be a module in the Programming Logic book. You may ask why are there two terms? Programming languages don t always use the same terminology to describe these reusable code blocks that can be called. Therefore the term module is used in the Programming Logic book to describe this general concept. When using Visual Basic, these will be referred to as procedures.

35 Housekeeping Recall that in the flowchart, the housekeeping() module is called next to print the REPORT_HEADING and COLUMN_HEADING constants and retrieves the first employee s name (primes the loop). For now the housekeeping logic is all part of Sub Main, but we ll comment the code so that we can see this logical chunk of the program. In later chapters, we will see how we can create more than one procedure in Visual Basic. This occurs in Chapter 9

36 Housekeeping in Visual Basic Local variables prompt and input

37 The Loop In the flowchart, the next statement to execute after housekeeping() finishes is the while loop that continues to execute until the user types in XXX when prompted for an employee s name. Within the while loop, detailloop() is called.

38 detailloop The work in detailloop() is to get an employee s gross pay; calculate deductions; calculate net pay; output employee s name, gross pay, deductions and net pay; and retrieving the next employee.

39 The Loop in Visual Basic For the interest of space, only the code inside of Sub Main is shown below. Get Gross Do calculations Output results Get next name

40 endofjob In the flowchart, when a user enters XXX for the employee s name, the program exits the while loop and calls the endofjob module The endofjob module is responsible for printing the value of the END_LINE constant. When endofjob finishes, control returns back to the mainline logic. As explained earlier, our endofjob logic will be implemented in Sub Main, but we will add a comment to illustrate where this chunk of logic begins.

41 Completed Code

Pseudo Code and Flow Charts. Chapter 1 Lesson 2

Pseudo Code and Flow Charts. Chapter 1 Lesson 2 Pseudo Code and Flow Charts Chapter 1 Lesson 2 Pseudocode Using Pseudocode Statements and Flowchart Symbols English-like representation of the logical steps it takes to solve a problem Flowchart Pictorial