CMPSC 201 - Ch. 2 Notes

Objective #1: Identify and create valid C++ identifiers (function and variable names.)

• see the rules on p. 35 of Bronson
  
  
• Use valid identifiers (often just called "variable names")
  • do not use keywords that are defined in the programming language
  • do not include spaces or other disallowed characters
  • do not use more than 31 characters
  • begin the identifier with a letter
    
    
• Use a conventional method of making your variables easy to read at a quick glance. For this class, we will begin variable identifiers with lowercase letters (eg. grade). However, if you wish to use more than one word within the identifier, you must capitalize the following words or parts of words (eg. semesterGrade, billGatesWealth). Please do not separate successive words with underscore characters ( _ ) as you may have seen in the textbook or other programming courses (eg. semester_grade, bill_gates_wealth).
  

Objective #2: Explain and appreciate the importance of using good C++ coding style.

• Note the different forms of style (good and bad) on p. 45
• comments can be inline (using // ) or block ( using /*....*/ ). However, I prefer that you use // comments on programming assignments. /* ... */ comments should only be used while debugging a program.
• For this course, you will be required to follow our Coding Standards. Otherwise, you will lose points on assignments even if a program happens to execute successfully.
• Since it is extremely rare for a programmer to work alone, his or her code must be read by coworkers from time to time. It is important to observe common coding standards so that others can read & understand your code with minimum difficulty. Also, others will need to integrate your code into their program, so following consistent coding standards will help avoid syntax and lexical errors.

Objective #3: List and explain the differences between the three basic data types in C++: integers, floating-points, and characters.

• When declaring a variable in a program, you must choose a data type. Declaring the variable is allocating it memory in order to store a value. Since different variables are meant to store values of different types and sizes, there are a number of data types in C++.
  
  
• You should select the proper data type for each variable that you use in a program in order to program efficiently.
  • this decreases memory usage.
  • this increases the speed of your program
    
    
• The following data types are common in C++. The most important data types for this course are int, double, and char.
  
  For integers (i.e. whole numbers):
  
  
  • short (-32,768 to 32,767; 2 bytes)
  • int    (-2,147,483,648 to 2,147,483,647; 4 bytes)
  • unsigned int     (0 to 4,294,967,295; 4 bytes )
  • long (-2,147,483,648 to 2,147,483,647; 4 bytes)
  • unsigned long (0 to 4,294,967,295; 4 bytes)
    
    

  For floating-point values (i.e. decimal numbers that need several digits of precision beyond the decimal point):

• float - (3.4E +/- 38 with 7 digits of precision; 4 bytes)
• double - (1.7E +/- 308 with 15 digits of precision; 8 bytes)
• long double - (1.2E +/- 4932 with 19 digits of precision; 10 bytes)

For characters (that is a single letter, digit, or symbol):

• char (-128 to 127; 1 byte)
• unsigned char (0 to 255; 1 byte)
  
  
• Even though the float data type is used by our textbook author to store decimal numbers and even though a float variable only uses 4 bytes, you should use the double data type in CMPSC 201.
  
  You don't have to understand the following discussion but it may be interesting to some of you. Decimal numbers (aka floating point numbers) are stored in a binary version of scientific notation (b * m * 2^e) with one bit (b) allocated to sign, some bits allocated to the mantissa (m) and the rest to the exponent (e). Therefore a float may have less bits allocated for the mantissa than for an int. In Visual C++, the mantissa for a float gets 23 bits when an int gets 31. Also rounding errors occur when converting real numbers to and from base 2. This combination sometimes results in a float that is slightly smaller than the expected value. If that float is supposed to store an integer, the truncation that results when it is assigned to an int often lowers the expected value by 1. Therefore, to avoid this problem, use a double that stores 52 bit mantissas.
  
• use single quotes when delimiting characters (eg. 'a'). For example,
  
  char letterGrade = 'A';
  
  and not
  
  char letterGrade = A;
  
• be familiar with the ASCII chart and memorize the ASCII values for 'a' (97), 'A' (65), & a blank space (32)

Objective #4: Correctly evaluate C++ expressions and identify the data type of their results.

• The common arithmetic operators are:

  +    for    addition
  -    for    subtraction
  *    for    multiplication
  /    for    division
  %    for    modulus (like finding the remainder of a division problem)

  • modulus examples: 
    • 10 % 3 = 1
    • 23 % 5 = 3
    • 10 % 2 = 0
      
      
• Remember to obey the order of operations ("Please Excuse My Dear Aunt Sally") that you learned in junior high or elementary school. That is, perform the following mathematical operations in this order: Parentheses, Exponentiation, Multiplication, Division, Addition and Subtraction.
  
  
• However, with regard to multiplication and division, you must work left to right within an algebraic expression. Be sure that you understand that    8 / 4 * 2    is equal to 4. The expression is not equal to 1 since the division is performed before the multiplication according to the order of operations.
  
  
• With regard to addition and subtraction, you must work left to right within an algebraic expression as well. Be sure that you understand that    8 - 4 + 2    is equal to 6 and NOT 2.
  
  
• Note that the modulus operator (%) has the same precedence as multiplication ( * ) and division ( / ). For example, the result of
  
  36 / 6 % 4 * 3 is 6 where the division, modulus, and multiplication are evaluated in that order form left to right.
  
  
• Use parentheses if necessary to override the order of operations in order to produce the desired result
  
• The final result of an expression that involves integers (an integer expression) such as (7 + 8) is an integer
• The final result of an expression that involves floating-point values (a floating-point expression) such as (3.0 + 0.003) is a floating-point value
• With a mixed mode expression such as numPurchased * 0.06 . The result of the expression is a double even if numPurchased is an int variable.
• When using a particular compiler, you should first identify the word size of the operating system. Your program will be more efficient if you use data types that are equivalent to the word size when possible. (The Windows operating system that we are using for this course has a 32 bit word size.)
• Try to avoid overflow, which is a condition when an integer becomes too large for its data type.  You may not be able to tell from the output (without checking it carefully, at least) that this logic error is occurring. For example, the code
  
  int a = INT_MAX;
  cout << a << endl;
  cout << a + 1 << endl;
  
  would result in the output
  
  2147483647
  -2147483648
  
  since the expression a + 1 overflows the int data type. You can think of the legal range of the integer data type as being a number line that goes from -2147483648 to 2147483647. When a value exceeds the right (positive) end of that number line, it wraps around and maps to a position on the left (negative) end of the number line. Of course, it is possible to overflow the double and char data types as well.
  
  
• Try to avoid underflow, which is a condition when a floating-point number becomes too small for its data type such as when a large negative exponent is used.
  
  double a = 1e-323;
  cout << a << endl;
  cout << a / 10 << endl;

  causes 0 to display for the second value due to underflow of the double data type.
  

Objective #5: Evaluate expressions appropriately with integer division.

• integer division truncates the results of expressions
• Do not assume that the compiler "rounds up".
• Example:
  
  int amount = 9;
  int numItems = 2;
  int average = 0;
  
  average = amount / numItems;
  
  The final value stored in the variable average is 4, not 4.5, due to integer division.

Objective #6: Use assignment statements with correct C++ syntax.

• The assignment operator in C++ is the equals symbol (=)
• An assignment statement is a statement that uses the assignment operator to assign a value to a variable. Examples:
  
  salary = 40000;
  poundsPressure = 15 + 12;
  sum = original + 300;
  salary = salary + raise;
  
  
• The assignment operator changes the value of the variable to its left after evaluating the expression on its right!!!!!!
  
  

i = 3 + 1000;    // the variable, i, ends up with the value 1003

• You can make multiple assignments in one C++ statement but I prefer separate statements for code written in this class.

• example:     i = j = k = 10;     // initializes all three variables to the value 10
  
  
• Sometimes it is convenient to store calculations in separate variables if they are going to be used later in the program; at other times, it is convenient to simply output the results directly to the screen.
  
  
• Use "whitespace" to make your arithmetic expressions and statements readable to fellow programmers even if the C++ compiler doesn't require whitespace

x = 3 + y;    is better than    x=3+y;

• Compound operators are sometimes useful if used carefully. For example:   
  
  j += 1;
  
       is equivalent to
  
        j = j + 1;
  

Objective #7: Use declaration statements with correct C++ syntax.

• Variables must be declared before they are used in C++. Get into the habit of doing this at the top of your program.
  
  
• Examples of declaration statements with explanatory inline comments:
  
  

  char grade;                             // a students semester grade

  unsigned long gatesWealth;  // the number of dollars in Bill Gates' savings account

  bool flag;                                 // whether user wishes to play the game again or not
  

• For this course, please do not initialize multiple variables in a single statement with commas even though your textbook and other C++ programmers may do so. Rather, you should use multiple statements for clarity and the preferred style for this course.
  
  Instead of
  
  int num = 0, salary = 0;
  
  or
  
  int num = 0,
      salary = 0;
  
  please use
  
  int num = 0;
  int salary = 0;
  
  
• You should get into the habit of initializing variables at the top of the program; otherwise "garbage values" (indeterminate values) may corrupt your program.
  
  
• Examples:
  
  
  • int numberOfPizzas = 3;          // declaring the variable & initializing it to the value of 3
  • double monthlyCarPayment;  // this unwisely only declares the variable
    
    
• true initialization occurs within variable declaration statements only. An assignment statement that assigns the value of zero to a variable towards the top of a program technically is not considered initialization.
• identifiers (i.e. variable names) are really just tags for memory addresses similar to how the Web page address www.microsoft.com is a tag for an IP address.
• As an exercise, write a program that prints out the indeterminant value of an uninitialized variable.

Objective #8: Use the endl manipulator correctly

• endl causes '\n' and it flushes the output stream
• '\n' is the newline escape sequence where \ is the escape operator in C++

Objective #9: Explain the differences between using pseudocode and flowcharts to developing a program's algorithm.

• pseudocode, see p. 21
• flowcharts, see pp. 12 & 21
• You will be responsible for turning in pseudocode with most if not all programming assignments that you complete for this course. We will not be using flowcharts.

Objective #10: Use a rounding algorithm.

• The following algorithm, which I call the "macho rounding algorithm", is not demonstrated in your textbook. It uses a combination of type casting and promotion to permanently change a variable's stored value to a rounded value.
  
• The following statements are basically equivalent in that they round any positive value stored in the variable num to the the nearest whole number
  
  num = int (num + 0.5);
  
  num = floor (num + 0.5);
  
• The first example above uses type casting to truncate the decimal places of the value after 0.5 is added to it.
  
• The second example uses the floor function which causes positive and negative numbers in the following set of parentheses to be truncated. You must add #include <cmath> at the top of your program in order to use the floor function.
  
• The following versions of the 3 example statements round num to the nearest hundredth's place.
  
  num = (int ((num * 100) + 0.5))/ 100.0;
  
  num = (floor ((num * 100) + 0.5))/ 100.0;
  
• By first multiplying by 100 to move the decimal place two places to the right and then using type casting to truncate the decimal places, you are then set up to simply divide by 100.0 to move the decimal point two places back to the left.
  
• You must divide by 100.0 and not the whole number 100. Otherwise integer division will occur and you will lose the desired decimal digits. By using 100.0 instead of 100, you are taking advantage of promotion where the C++ compiler will promote the numerator int operand to a double in order to match the 100.0 denominator term which is a double.