VB Lecture Notes - Variables & Data Types

Objective #1: Name variables using the appropriate data type prefixes and the proper capitalization.

• A variable is used in a computer program to store a number or piece of text. In algebra, you often use the variable name x or y. However, in computer programming, we usually use whole words or even phrases as variable names such as price or annualSalary. A variable can change the value that it stores while a program executes.
  
  
• Use sensible and meaningful variable names that make sense. Good variable names would be score, age, and name rather than single letters like s, a, n or even x or y. Whole words should be used so that other people (teachers, coworkers, and even yourself) can understand your program more easily.
  
  
• If a variable name uses two or more words, you must concatenate the multiple words together into one word being sure to capitalize the successive words. Variable names such as numberOfStudents, numStudents, totalPrice, and firstName are examples.
  
  
• You must being a variable name with a letter and not a digit or a symbol. Thus the variable names 2Many or $salary would not be legal. You cannot include a space within a variable name. To be safe, you should not use more than 31 characters in a variable name.
  

Objective #2: Understand each of the basic data types used by Visual Basic.

• You must carefully choose the data type for each variable that you declare in your program.You must use a data type that can store numbers that are in the range of values that you expect the variable to possibly hold during a program's execution. Try not to choose data types that are way too large or you will be guilty of wasting memory.
  
  In this course, we will mainly be using four data types: Integer, Double, String and Boolean.
  
  
• If you need to store the number of donuts purchased at a store, you should probably use a variable with the Integer data type since donuts are typically sold as wholes. No one buys half of a donut. The Integer data type does not allow decimal places to be stored in the variable.
  
  
• If you needed to accurately store the price of an item at a store, you would use a Double variable since the price is probably a decimal number like 10.99. The Double data type allows the decimal places to be stored.
  
  
• If you need to store a word or phrase into a variable, you should use the String data type. When you type a string you need to use quotation marks around the letters. The string "apple" is different from the string " apple" since the latter has a leading blank space in front of the letter a.
  
  
• If you need to store the value True or False, you should use the Boolean data type. We will not be making use of this data type until later in the course.
  
  
• There are other Visual Basic data types than the 4 shown in the accompanying chart, but these are the main ones that we will be using in this course.

• The Integer data type cannot store numbers greater than 2147483647 (about 2 billion). If you try to store a number larger than that, an overflow error occurs. Variables of the Double data type overflow at a point much higher than Integer's so generally you don't have to worry about overflow errors with Double variables.
  
  
• The Unicode chart (formerly called the ASCII chart - pronounced "ask-key") is a list of letters and symbols along with their corresponding numeric values that the international community has agreed upon. Every letter and symbol of every language has been given a range of numbers between 0 and roughly 65000. The lowercase English alphabet goes from a which is 97 to z which is 122. The uppercase alphabet goes from A which is 65 to Z which is 90. In this course, you are required to memorize uppercase A which is 65, lowercase a which is 97, and blank space which is 32. From those values, you can derive the other consecutive values and you can determine wether one word or phrase is "alphabetically less than or greater than" another word or phrase.
  
  
• While you will not be tested on the following explanation of why overflow occurs, you may find it interesting.
  
  The reason why an Integer can only store a whole number as high as 2147483647 is because of the fact that an Integer is 4 bytes in size. Since 4 bytes is equivalent to 32 bits, the largest binary value that can be stored in an Integer variable is 1111 1111 1111 1111 1111 1111 1111 1111. However, the leading (leftmost) bit (known as the sign bit) is used to keep track of whether the value is positive or negative, so only 31 bits are used to store the variable's actual value. Since 2^31 is 2147483648, you may think that 2147483648 should be possible as an Integer value. But since the value 0 must be a possible value, 2147483647 (which is 2^31 - 1) is the largest value that can be stored in an Integer variable. On the other hand, -2147483648 is the least (most negative) value that can be stored in an Integer.
  

Objective #3: Use Dim statements to declare variables and understand the physical process of memory (RAM) allocation.

• You should get used to declaring all variables in a program with Dim statements. Declaration statements are used to declare variables. A variable should be declared one time before it is used later in the program. It is an error to declare a variable twice or more in a program. Declaring a variable associates a variable name with an area of memory (i.e. RAM) so that the variable can store a value (numeric or string). Declaring a variable also specifies a certain data
  
  Dim price As Double = 0
  
  causes 8 bytes of memory to be reserved to store the value of the variable price. Furthermore, VB automatically Double variable to the value 0.0. It is usually a good idea to initialize a variable to a number such as 0 when it is declared.
  
  
• Dim is an abbreviation for "dimension". In old-fashioned versions of BASIC programming language, to dimension a variable meant to make room for the variable in the computer's memory.
  
  
• If you attempt to store a decimal number in an Integer variable, Visual Basic will round the number. For example, the statement
  
  Dim price As Integer = 3.6
  lblOutput.Text = Str(price)
  
  results in the whole number 4 being stored in the variable price and then displayed in the label.
  
  However, due to the type of rounding used in Visual Basic if the number is 2.5, the value 2 would be stored in price since 2 is an even number. If the number is 3.5, the value 4 would be stored. This type of rounding is called "Banker's Rounding". Search Google or see this link for more information.
  

Objective #4: Determine the scope of a variable.

• A variable's scope determines where a variable can be used in a program. We will study 2 levels of variable scope, local and module.
  
  
• If a variable is declared with a Dim statement within a method, then the variable is considered to be a local variable and it can only be used within that method. It is NOT visible to any other method and cannot be used by any other method. We say that local variables have narrow scope.
  
  In the example below, num is a local variable in the method btnCompute_Click because it is declared inside that method with a Dim statement. A compile error would occur if you tried to use amount in the btnClear_Click method since num isn't declared there. The scope of the variable num is considered to be the body of the method btnCompute_Click
  
  Private Sub btnCompute_Click()
     Dim num As Integer = 0
  
     lblOutput.Text = num
  End Sub
  
  Private Sub btnClear_Click()
     lblOutput.Text = ""
     ' it would cause a compile error to use num here
  End Sub
  
  
  
• Unfortunately, local variables lose their values and "disappear" after a method ends. That is, as soon as Visual Basic executes the End Sub statement, all local variables that are declared and used within that method are erased from the memory of the computer.
  
  
• On the other hand, if a variable is declared with a Dim statement at the top of a form (i.e. class) outside of the methods in the form, then it can be used in any method in the form. In this case, the variable is considered to be a module variable and it has module scope. Module variables should be named with an m prefix (e.g. mNum) so that other programmers can easily identify them as module variables. Module variables have a scope that is considered to be wider than the scope of local variables.
  
  The scope of the variable mNum is the whole form in the example below.
  
  Dim mNum As Integer = 0
  
  Private Sub btnCompute_Click()
     lblOutput.Text = Str(mNum)
  End Sub
  
  Private Sub btnClear_Click()
     ' it would be legal to use mNum here
     lblOutput.Text = ""
  End Sub
  
  
  
• You should try to avoid using too many module variables in a program. They can make it very difficult to find logic errors. They sometimes get changed accidentally and affect other methods. Also, fellow programmers will find it difficult to read your programs if you use many module variables.
  
  
• Local variables are considered to be safer than module variables because they cannot be "corrupted" other methods. Since a local variable disappears when a method ends, it cannot affect other methods. It is safest therefore to keep the scope of your variables as narrow as possible.
  
  
• When a variable is declared a few bytes of computer memory is reserved to store its value. When a method ends, the memory that was used to store the value of a local variable is no longer reserved for that variable. Eventually, another variable that is declared later in the program may use the same exact of memory address. Module variables have a lifetime that is longer than local variables since their memory is reserved until the form is unloaded. Programmers should limit the lifetime of variables as much as possible in order to use memory efficiently. Using too much memory will slow down your program and sometimes crashes the program or computer.
  

Objective #5: Use constants.

• Besides variables, an effective program might include constants. A constant looks like a variable but instead of the keyword Dim being used in its declaration statement, the keyword Const is used as in this example
  
  Const PA_SALES_TAX As Double = 0.06
  
  
• Constants should usually have module scope since they are often intended to be used in multiple methods within the form.
  
  
• You should use constants instead of variables for storing values that should not change as a program executes. For example, the variable numPurchased may change depending on what a customer types into a textbox. But the PA sales tax rate cannot be changed by a customer while the program executes so it should be made into a constant rather than a variable. This keeps logic errors from occurring. If a programmer accidentally types an assignment statement like
  
  PA_SALES_TAX = 0.07
  
  later in the program in an attempt to change the value stored in the constant, Visual Basic will produce a compile error and alert the programmer.
  
  
• Also, the letters in the name of a constant should all be uppercase with an underscore being used to separate multiple words. This is done so that constants can be spotted at a quick glance through a long program.
  
  
• Some good names for constants would be: NUM_SLICES_PER_PIZZA, DOZEN, SPEED_OF_LIGHT
  
  
• Do not "hardwire" your code with a "magic number". For example, the following code segment is used to compute the total price of a customer's purchase of cookies
  
  totalPrice = numDonuts * 0.75
  
  What the programmer should do is to create a constant for 1.39 and reuse that constant anywhere in the program that the price per cookie needs to be used as in
  
  Const PRICE_PER_DONUT As Double = 0.75
  . . .
  totalPrice = numDonuts * PRICE_PER_DONUT