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. Do not use single letters as variable names like x or y. A program that uses meaningful, descriptive variable names is called self-documenting. This is done so that others (teachers, coworkers, and even yourself) can understand your program easier.
  
• A good practice for beginners is to name each variable with a prefix that identifies its data type (see below). This method of naming variables is called the Hungarian Notation. A good variable name might be intRuns to store the number of runs scored in a baseball game program. However, you may use multiple words to more fully describe the variable's purpose. A better variable name might be intRunsScored.
• Each word in the variable name (besides the prefix) should be capitalized so it's easier to read.
• In most programming languages, including VB, a variable name must begin with a letter and not a digit or a symbol. Thus the variable names 2Many or %More would not be valid. Technically, the variable name int2Many would be valid since a variable name can include digits as long as a letter is the first character. You cannot include a space within a variable name. Therefore the variable name intRuns Scored would not be valid. To be safe, you should not use more than 31 characters in a variable name.
  
• Examples of good variable names: intNumStudents, dblTotalPrice, dblSalary, strFirstName

Objective #2: 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 type for the variable which determines how many bytes of memory are reserved to store the variable's value. For example,
  
  Dim dblPrice As Double = 0.0
  
  causes 8 bytes of memory to be reserved to store the value of the variable dblPrice. Furthermore, VB automatically initializes the Double variable to the value 0.0. While the ...= 0.0 part of the declaration statement above is optional, it is always a good idea to initialize a variable to a number such as 0 when it is declared. In some computer languages such as C++, variables are not automatically initialized to zero when they are declared. Double variables should usually be initialized to 0.0 while Integer variables should usually be initialized to 0 as in
  
  Dim intNum As Integer = 0
  
  
• 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.

Objective #3: 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.
• For example, if you needed to store the number of hamburgers sold at a McDonald's restaurant in one day, you should probably use a variable with the Integer data type to allow for a maximum number of 2147483647 hamburgers sold and since hamburgers are sold by the whole unit and Integer variables are meant to store whole numbers. However, if you needed to store the number of hamburgers sold by ALL of the McDonalds restaurants in the U.S. throughout history, it would probably be necessary to use a variable with the Double data type to allow for 3 billion or more hamburgers since the signs at McDonalds now claim to have served "billions".

• It is dangerous to mix data types in Visual Basic as in the assignment statement,
  
  dblTotal = intApplesPrice + dblCandyPrice
  
  since an Integer and a Double are being added in what is called mixed-mode addition. Realize that you are asking VB to add a 4-byte variable to an 8-byte variable! That is sort of like mixing apples and oranges. If the expression is being stored to an Integer variable, such as:
  
  intTotal = intApplesPrice + dblCandyPrice
  
  the result will be rounded! If the expression is being stored to a Double variable as in
  
  dblTotal = intApplesPrice + dblCandyPrice
  
  the result will have the expected decimal digits. Note that you can't always assume that a computer programming language allows you to mix data types within expressions. In some other languages, truncation will occur causing the decimal portion of a computed number to be lost.
  
  
• If you try to add one or more to an Integer variable that has the value 2147483647, an overflow error occurs since the maximum value. Variables of the Double data type overflow at a point much higher than Integer's.
  
  
• 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.
  
  
• 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 VB programming 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.
  

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 in a method, then the variable can only be used within that method. It is considered to be a local variable in that case since it is NOT visible to any other method and cannot be used by any other method. We say that local variables have narrow scope, that is compared to module variables discussed below.
• 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. mintNumStudents) 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.
• 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. By nature, a local variable disappears when a method ends and 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 mdblPA_SALES_TAX As Double = 0.06
  
  
• You should use constants instead of variables for storing values that should not change as a program executes. For example, the variable mintNumPurchased 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
  
  mdblPA_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.
• Constants usually have module scope so that they can be used in multiple methods on a form.
• Some good names for constants would be: mintNUM_SLICES_PER_PIZZA, mintDOZEN, mdblCUTOFF_FOR_A = 89.5, etc.
• Furthermore, constants should usually have module scope since they are often intended to be used in multiple methods within the form.
• Do not "hardwire" your programming logic in assignment statemetns with a "magic number". For example, the following code segment is used to compute the total price of a customer's purchase of cookies
  
  mdblFinalPrice = mintNumCookiesPurchased * 1.39
  
  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
  
  mdblFinalPrice = mintNumCookiesPurchased * mdblCOOKIE_PRICE