1. Objects Types, Variables, and Constants 1 Chapter 3

2. Overview of C++ Statements 2 C++ Statements Declarations;Expressions; Other Objects Operations

3. Expressions In a C++ program, any finite sequence of objects and operations that combine to produce a value is called an expression. Examples from our temperature problem: 1.8 * celsius 1.8 * celsius + 32 3 Even: 1.8; 32; "Hello"; 1 + 1; ;;;; We focus now on C++ objects and will look at operations later. 1.8 fahrenheit = 1.8 * celsius + 32 Aside #1: expression ; is a statement.) Aside #2: expressions may be empty

4. Object Categories There are three kinds of objects: Literals: unnamed objects having a value ( 0, -3, 2.5, 2.998e8, 'A', "Hello\n",... ) Variables: named objects whose values can change during program execution Constants: named objects whose values cannot change during program execution 4 See Footnote on p. 48 Study §3.2 Have memory allocated to them

5. Literals – literals are integers: –int literals are integers: -27, 0, 4, +4 or E – There are just two bool literals: false, true 5 Enclose in ' Enclose in " – char literals are single characters: 'A', 'a', '9', '$', '?',... – string literals are sequences of characters: " Hello", "Goodbye", "Goodbye\n" 5 basic types literals are real numbers, and can be: –double literals are real numbers, and can be: fixed-point:,... fixed-point: -0.333, 0.5, 1.414,... floating-point:,... floating-point: 2.998e8, 0.2998e9,... Not inter- changeable Some Variations: unsigned, long, short Variations: float, long double

6. Variable Declarations Examples: int idNumber; int age = 18; double celsius, kelvin = 0; cin >> celsius; double fahrenheit = 1.8 * celsius + 32; char letterGrade = 'A'; bool ok, done = false; 6 Declare only once Variables are used to store values, and can be either uninitialized or initialized. They must be before they are used. Variables are used to store values, and can be either uninitialized or initialized. They must be declared before they are used. Pattern: Pattern: type name; type name = expression; Allocates a memory location for values of this type and associates its address with name Not a declaration

7. Assignment Statements Examples: age = 19; celsius = 1.1 * celsius; letterGrade = 'B'; done = true; 7 Pattern: Pattern: name = expression; The value of a variable can be changed during execution by an assignment statement. Changes value in name's memory location to value of expression

8. Constant Declarations const char MIDDLE_INITIAL = 'A'; const string PROMPT = "Enter a number: "; 8 Pattern: Pattern: const type NAME = expression; Constants are used to represent a value with a meaningful name, and must be initialized. They cannot be changed later. Could use in Proj. 1.3 Examples: const int MAX_SCORE = 100; const double PI = 3.14159265359; Allocates a memory location for values of this type, associates its address with NAME, puts value of expression in it, and locks it.

9. Identifiers The name of an object is called an (because it identifies the object). The name of an object is called an identifier (because it identifies the object). C++ identifiers must begin with a letter (underscores are permitted, but discouraged) followed by zero or more letters, digits or underscores. Valid:,... Valid: age, r2d2, myGPA, MAX_SCORE,... Invalid:,... Invalid: 123go, coffee-time, sam's, $name,... 9 May not be C++ keywords (See Appendix B) See slide 24

10. Conventions We will use the following commonly-used convention to keep variable and constant objects distinct. Constant names: all uppercase, with multiple words separated by underscores (e.g., )Constant names: all uppercase, with multiple words separated by underscores (e.g., MAX_SCORE ) Variable names: all lowercase, but the first letter of each word after the first capitalized (e.g., )Variable names: all lowercase, but the first letter of each word after the first capitalized (e.g., lastName ) 10 Use meaningful identifiers for readability! “camelback” notation

11. Represented in memory by a code. – –ASCII uses 8 bits (1 byte) to represent a character, allowing for 2 8 = 256 different characters. Objects char Objects 'a' = 97 = 01100001 '0' = 48 = 00110000 11 p. 61 App. A Java chars can be treated as small integers; e.g,. char ch1 = 'A', ch2; int x = 2*ch1 + 1; ch2 = ch1 + 1; cout << x << ' ' << ch2 << '\n'; Output? 131 B 01000001 65 = Most used code is ASCII: Most commonly used code is ASCII: 'A' = –Unicode's first version used 16 bits to represent a character, allowing for 2 16 = 65,536 different characters. Now, 16, 24, or 32 bits. See Other Course Information class page

12. Escape Characters C++ provides a number of : C++ provides a number of escape characters: 12 '\n' newline character '\t' horizontal tab '\v' vertical tab '\f' form feed '\a' alert/bell '\\' backslash char '\'' apostrophe '\"' double quote '\ooo' char with octal code ooo '\xhhh' char with hex code hhh See Appendix A

13. Objects int Objects Three forms: –decimal (base-10): begin with a digit or sign (-45, -2, 0, +21, 36, 65536,...) –decimal (base-10): 0 or begin with a nonzero digit or sign (-45, -2, 0, +21, 36, 65536,...) –octal (base-8): begin with a followed by digits (01, 02, 03, 04, 05, 06, 07, –octal (base-8): begin with a 0 followed by octal digits (01, 02, 03, 04, 05, 06, 07, 010, 011, 012,..., 017, 020, 021, …) 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11,...) –hexadecimal (base-16): begin with followed by digits with a, b, c, d, e, f = 10, 11, 12, 13, 14, 15 (0x1, 0x2,..., 0x7, 0x8, 0x9, –hexadecimal (base-16): begin with 0x followed by digits with a, b, c, d, e, f = 10, 11, 12, 13, 14, 15 (0x1, 0x2,..., 0x7, 0x8, 0x9, 13 See second item on Other Course Information class page

14. Objects unsigned Objects For objects whose values are never negative, C++ provides the unsigned type. They also may be expressed in decimal, octal, and hexadecimal forms. The major advantage of using unsigned instead of int when values being processed are known to be nonnegative is that larger values can be stored. 14

15. Ranges of Integer Values Using 32 bits, int values range from -2 31 (-2147483648) to 2 31 -1 (2147483647); unsigned values range from 0 to 2 32 -1 (4294967295). An int value "loses" one of its bits to the sign, and so the maximum int value is about half of the maximum unsigned value. 15 INT_MIN defines INT_MIN, INT_MAX, UINT_MAX, and other constants that specify ranges of C++ integers; does this for C++ real values. (See App. D) UINT_MAXINT_MAX

16. 16 //-- Program to demonstrate the effects of overflow #include using namespace std; int main() { int number = 2; for (int i = 1; i <= 15; i = i + 1) { cout << number << '\n'; number = 10 * number; } Output: 2 20 200 2000 20000 200000 2000000 20000000 200000000 2000000000 -1474836480 -1863462912 -1454759936 -1662697472 552894464 Strange Behavior of Integer Overflowoverflow Overflow: when a value gets out of range; for example, an integer exceeds INT_MAX = 2 31 - 1 = 2147483647.

17. 17 //-- Program to demonstrate the modular "wrap-around" effect of overflow #include using namespace std; int main() { int number = INT_MAX - 3; for (int i = 1; i <= 7; i = i + 1) { cout << number << '\n'; number = number + 1; } Output: 2147483644 2147483645 2147483646 2147483647 -2147483648 -2147483647 -2147483646 Why this strange behavior? Check INT_MAX + 1, INT_MAX + 2,... INT_MAX INT_MIN Arithmetic is modular INT_MIN... INT_MAX

18. Representation int Representation Integers are often represented internally in the format, where the high- order (leftmost) bit indicates the number’s sign: twos-complement format, where the high- order (leftmost) bit indicates the number’s sign: 2 10 = 0000000000000010 2 1 10 = 0000000000000001 2 0 10 = 0000000000000000 2 -1 10 = 1111111111111111 2 -2 10 = 1111111111111110 2 Here we show 16 bits, but 32 or 64 are more common. 18 Sec. 3.3

19. Two's-Complement To find twos-complement representation of a negative number (e.g., -12): Represent its absolute value in binary: (0000000000001100) (0000000000001100) Invert (complement) the bits: (1111111111110011) (1111111111110011) Add 1 19 (1111111111110100) (1111111111110100) Simpler: Flip all bits to the left of rightmost 1. Stop here for nonnegative numbers Try practice exercises — Week 3 of schedule

20. 20 + 0 1 0 0 1 1 1 10 * 0 1 0 0 0 1 0 1 5 + 7: 0000000000000101 +0000000000000111 5 + –6: 0000000000000101 +1111111111111010 0000000000001100 111  carry bits 1111111111111111 Why Use Two's Complement? Because usual algorithms for +, * work!

21. Objects double Objects = 1.0111 2  2 2 01000000000101110000000000000000000000000000000000000000000000000 sign (1 bit) mantissa (52 bits) exponent (11 bits) 21 1023 Real values are often represented in 64 bits using the IEEE floating point standard: 5.75 = 101.11 2 See Ch. 3, pp. 59-61 float (single precision): bias = 127; exponent: 8 bits mantissa: 23 bits Try practice exercises on course schedule "bias" +

22. 22 //-- Effect of roundoff error #include using namespace std; int main() { for (double x = 0; x != 50.0; x = x + 0.1) { doouble y = x * sqrt(1 + sin(x)); cout << x << " " << y << '\n'; //if (x > 60) break; } Execution: 0 0.1 0.104873 0.2 0.218968... 22.6 14.7859 22.7001 13.4103 22.8001 11.9884... 49.9998 42.937 50.0998 45.7826 50.1998 48.5246... 100.099 76.3241... So they can't be stored exactly; error in this representation is called roundoff error. Patriot missile failure See Other Course Information Problem:Binary representations of most real numbers do not terminate; e.g., 13.1 = 1101.00011001100110011…

23. 23 /* temperature.cpp converts a Celsius temperature to Fahrenheit. John Doe Lab 1 Jan. 6, 2011 CPSC 104X Input: A Celsius temperature Output: Corresponding Fahrenheit temperature -----------------------------------------------*/ #include // cin, cout, > using namespace std; int main() { cout << "John Doe CPSC 104X -- Lab 1\n\n"; cout << "** Convert Celsius temps to Fahrenheit **\n"; cout << "Please enter a temperature in Celsius: "; double celsius; cin >> celsius; double fahrenheit = 1.8 * celsius + 32; cout << celsius << " degrees Celsius is " << fahrenheit << " degrees Fahrenheit.\n"; }

24. 24 The name of the song is called "Haddocks' Eyes". "Oh, that's the name of the song, is it?" Alice said, trying to feel interested. "No, you don't understand," the Knight said, looking a little vexed. "That's what the name is called. The name really is 'The Aged Aged Man'." 'Then I ought to have said, "That's what the song is called"?' Alice corrected herself. "No, you oughtn't: that's quite another thing! The song is called 'Ways and Means': but that's only what it's called, you know!" "Well, what is the song, then?" said Alice, who was by this time completely bewildered. "I was coming to that," the Knight said. "The song really is 'A-Sitting On a Gate': and the tune's my own invention." Lewis Carroll, Through The Looking Glass The name of the student's letter grade is called " letterGrade." "Oh, that's the name of the student's letter grade, is it?" Alice said, trying to feel interested. "No, you don't understand," the Knight said, looking a little vexed. "That's what the name is called. The name really is 0x123abc, a memory location that stores the student's letter grade." 'Then I ought to have said, "The student's letter grade is 0x123abc"? Alice corrected herself. "No, you oughtn't: that's quite another thing! The student's letter grade is called 'A': but that's only what it's called, you know!" "Well, what is the letter grade, then?" said Alice, who was by this time completely bewildered. "I was coming to that," the Knight said. "The student's letter grade really is 10000001 and it's my own initialization."

25. A int age: 0xbfe0b82c int idNumber: 0xbfe0b828 int x: 0xbfe0b824 int y: 0xbfe0b820 double celsius: 0xbfe0b818 double kelvin: 0xbfe0b810 double fahrenheit: 0xbfe0b808 char letterGrade: 0xbfe0b807 char a: 0xbfe0b806 char b: 0xbfe0b805 char c: 0xbfe0b804 bool ok: 0xbfe0b803 bool done: 0xbfe0b802 bool d: 0xbfe0b801 bool e: 0xbfe0b800 int age = 18; int idNumber, x, y; double celsius = 0, kelvin = 0; double fahrenheit = 1.8 * celsius + 32; char letterGrade = 'A', a, b, c; bool ok, done = false, d, e; int age: 0012FF60 int idNumber: 0012FF54 int x: 0012FF48 int y: 0012FF3C double celsius: 0012FF2C double kelvin: 0012FF1C double fahrenheit: 0012FF0C char letterGrade: 0012FF03 char a: 0012FEF7 char b: 0012FEEB char c: 0012FEDF bool ok: 0012FED3 bool done: 0012FEC7 bool d: 0012FEBB bool e: 0012FEAF Press any key to continue... Unix/Linux Visual C++

26. B Enter character (* to stop): A 01000001 Enter character (* to stop): B 01000010 Enter character (* to stop): C 01000011 Enter character (* to stop): Z 01011010 Enter character (* to stop): a 01100001 Enter character (* to stop): ; 00111011 Enter character (* to stop): @ 01000000 Enter character (* to stop): *

27. C Enter number (-999 to stop): 1 00000000000000000000000000000001 Enter number (-999 to stop): 2 00000000000000000000000000000010 Enter number (-999 to stop): 3 00000000000000000000000000000011 Enter number (-999 to stop): 1024 00000000000000000000010000000000 Enter number (-999 to stop): -1 11111111111111111111111111111111 Enter number (-999 to stop): -2 11111111111111111111111111111110 Enter number (-999 to stop): -3 11111111111111111111111111111101 Enter number (-999 to stop): -999

28. D Enter number (-99 to stop): 5.75 01000000101110000000000000000000 Enter number (-99 to stop): 1 00111111100000000000000000000000 Enter number (-99 to stop):.25 00111110100000000000000000000000 Enter number (-99 to stop): -.25 10111110100000000000000000000000 Enter number (-99 to stop): 13.1 01000001010100011001100110011010 Enter number (-99 to stop): -.1 10111101110011001100110011001101 Enter number (-99 to stop):.3 00111110100110011001100110011010 Enter number (-99 to stop): -99

29. E #include using namespace std; int main() { cout << "INT_MAX = " << INT_MAX << endl << "INT_MIN = " << INT_MIN << endl << "UINT_MAX = " << UINT_MAX << endl << "SHRT_MAX = " << SHRT_MAX << endl << "SHRT_MIN = " << SHRT_MIN << endl << "LONG_MAX = " << LONG_MAX << endl << "LONG_MIN = " << LONG_MIN << endl << "CHAR_MAX = " << CHAR_MAX << endl << "CHAR_MIN = " << CHAR_MIN << endl << "FLT_MAX = " << FLT_MAX << endl << "FLT_MIN = " << FLT_MIN << endl << "DBL_MAX = " << DBL_MAX << endl << "DBL_MIN = " << DBL_MIN << endl << "LDBL_MAX = " << LDBL_MAX << endl << "LDBL_MIN = " << LDBL_MIN << endl << "FLT_EPSILON = " << FLT_EPSILON << endl << "DBL_EPSILON = " << DBL_EPSILON << endl << "LDBL_EPSILON = " << LDBL_EPSILON << endl; } INT_MAX = 2147483647 INT_MIN = -2147483648 UINT_MAX = 4294967295 SHRT_MAX = 32767 SHRT_MIN = -32768 LONG_MAX = 2147483647 LONG_MIN = -2147483648 CHAR_MAX = 127 CHAR_MIN = -128 FLT_MAX = 3.40282e+038 FLT_MIN = 1.17549e-038 DBL_MAX = 1.79769e+308 DBL_MIN = 2.22507e-308 LDBL_MAX = 1.79769e+308 LDBL_MIN = 2.22507e-308 FLT_EPSILON = 1.19209e-007 DBL_EPSILON = 2.22045e-016 LDBL_EPSILON = 2.22045e-016

30. F #include using namespace std; int main() { for (double x = 0; x != 50.0; x = x +.01) { double y = x * sqrt(1 + sin(x)); cout << x << " " << y << endl; } 4.37001 1.05283 4.38001 1.0247. 49.9576 41.7073 49.9676 42.0003 49.9776 42.2923 49.9876 42.5834 49.9976 42.8735 0 0.01 0.0100499 0.02 0.020199 0.03 0.0304466 0.04 0.0407919 0.05 0.0512342 0.06 0.0617727 0.07 0.0724066 0.08 0.0831352 0.09 0.0939575 0.1 0.104873 0.11 0.115881 0.12 0.12698. 4.33 1.16366 4.34 1.1362 4.35 1.10858 4.36 1.08078 50.0076 43.1627 50.0176 43.4509 50.0276 43.7381 50.0376 44.0244 50.0476 44.3096 50.0576 44.5939 50.0676 44.8772.