Objects

Types, Variables, and Constants

Chapter 3

1
 Overview of C++ Statements
C++ Statements

Declarations; Expressions; Other

Objects
Operations

2
 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
1.8 * celsius
1.8 * celsius + 32 Even:
fahrenheit = 1.8 * celsius + 32 1.8;
32;
Aside #1: expression; is a statement.) "Hello";
1 + 1;
Aside #2: expressions may be empty ;;;;

We focus now on C++ objects

and will look at operations later. 3
 Study
§3.2

Object Categories
See Footnote
There are three kinds of objects: on p. 48

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 Have
memory

Constants: named objects whose values

allocated to
them

cannot change during program execution

4
5 basic
types Literals
Some Variations:
unsigned, long, short
– int literals are integers:
Variations:
-27, 0, 4, +4 float, long double

– double literals are real numbers, and can be:

fixed-point: -0.333, 0.5, 1.414, ... or E

floating-point: 2.998e8, 0.2998e9, ...

– There are just two bool literals: false, true
– char literals are single characters: Enclose in '

'A', 'a', '9', '$', '?', ... Not inter-

– string literals are sequences of characters:
changeable

"Hello", "Goodbye", "Goodbye\n" Enclose in "

5
 Variable Declarations
Variables are used to store values, and can be either
uninitialized or initialized. They must be declared
before they are used.
Declare
Examples: only once
int idNumber;
int age = 18;

Not a
double celsius,
declaration kelvin = 0;
cin >> celsius;
double fahrenheit = 1.8 * celsius + 32;
char letterGrade = 'A';
Allocates a memory
bool ok, done = false; location for values of
this type and associates

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

Pattern: name = expression;

7
 Constant Declarations
Constants are used to represent a value with a
meaningful name, and must be initialized. They
cannot be changed later.
Examples:
Could
const int MAX_SCORE = 100; use in
Proj. 1.3
const double PI = 3.14159265359;
const char MIDDLE_INITIAL = 'A';
const string PROMPT = "Enter a number: ";

Pattern: const type NAME = expression;

Allocates a memory location for values of
this type, associates its address with NAME,
puts value of expression in it, and locks it. 8
 Identifiers
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. May not be C++
keywords
(See Appendix B)
Valid: age, r2d2, myGPA, MAX_SCORE,...

Invalid: 123go, coffee-time, sam's, $name,...

See
9
slide 24
 Use
meaningful identifiers
Conventions for readability!

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., MAX_SCORE)
• Variable names: all lowercase, but the first
letter of each word after the first capitalized
(e.g., lastName) “camelback”
notation
10
 char Objects
Represented in memory by a code.
– ASCII uses 8 bits (1 byte) to represent a p. 61
App. A
character, allowing for 28 = 256 different
characters.
– Unicode's first version used 16 bits to represent
Java a character, allowing for 216 = 65,536 different
See Other
Course characters. Now, 16, 24, or 32 bits.
Information
class page
chars can be treated as small
Most commonly used integers; e.g,.
char ch1 = 'A',
code is ASCII: ch2;
int x = 2*ch1 + 1;
'A' = 65 = 01000001 ch2 = ch1 + 1;
cout << x << ' '
'a' = 97 = 01100001 << ch2 << '\n';
'0' = 48 = 00110000 Output? 131 B 11
 Escape Characters
C++ provides a number of escape characters:
'\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 See
Appendix A
'\xhhh' char with hex code hhh

12
 int Objects
Three forms:
– decimal (base-10): 0 or begin with a nonzero
digit or sign (-45, -2, 0, +21, 36, 65536, ...)
– octal (base-8): begin with a 0 followed by octal digits
(01, 02, 03, 04, 05, 06, 07,
See second
item on 010 , 011 , 012, ..., 017,
Other
Course 020, 021, …)
Information
class page
– 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,
0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
0x10, 0x11, ...) 13
 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
 Ranges of Integer Values
INT_MIN INT_MAX

Using 32 bits, int values range from

-231 (-2147483648) to 231-1 (2147483647);
unsigned values range from
0 to 232-1 (4294967295). UINT_MAX

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.
<climits> defines INT_MIN, INT_MAX,
UINT_MAX, and other constants that specify
ranges of C++ integers; <cfloat> does this
for C++ real values. (See App. D) 15
 Strange Behavior of Integer Overflow
Overflow: when a value gets out of range; for example,
an integer exceeds INT_MAX = 231 - 1 = 2147483647.

//-- Program to demonstrate the effects of overflow Output:

#include <iostream> 2
using namespace std; 20
200
int main() 2000
{ 20000
int number = 2; 200000
2000000
for (int i = 1; i <= 15; i = i + 1) 20000000
{ 200000000
cout << number << '\n'; 2000000000
number = 10 * number; overflow -1474836480
} -1863462912
} -1454759936
-1662697472
552894464
16
 Why this strange
behavior?
Check INT_MAX + 1,
INT_MAX + 2, . . .

//-- Program to demonstrate the modular "wrap-around" effect of overflow

#include <iostream>
#include <climits>
using namespace std;

int main()
{
Output:
int number = INT_MAX - 3;
2147483644
for (int i = 1; i <= 7; i = i + 1)
2147483645
{
2147483646
cout << number << '\n';
INT_MAX 2147483647
number = number + 1;
INT_MIN -2147483648
}
-2147483647
}
-2147483646
Arithmetic is modular

INT_MIN . . . INT_MAX
17
 Sec. 3.3

int Representation
Integers are often represented internally in the
twos-complement format, where the high-
order (leftmost) bit indicates the number’s sign:
210 = 00000000000000102
110 = 00000000000000012
010 = 00000000000000002
-110 = 11111111111111112
-210 = 11111111111111102

Here we show 16 bits, but 32 or 64 are more

common.
18
 Two's-Complement
To find twos-complement representation of a
negative number (e.g., -12):
Represent its absolute value in binary:
(0000000000001100) Stop here for
nonnegative Try
Invert (complement) the bits: numbers practice
exercises
— Week 3
(1111111111110011) of schedule

Add 1
(1111111111110100)
Simpler: Flip all bits to the left of rightmost 1.
19
 Why Use Two's Complement?
Because usual algorithms for +, * work!

* 0 1
+ 0 1
0 0 0
0 0 1
1 0 1
1 1 10
5 + 7:
111 carry bits
0000000000000101
+0000000000000111
0000000000001100

5 + –6:
0000000000000101
+1111111111111010
1111111111111111
20
 double Objects See Ch. 3,
pp. 59-61

Real values are often represented in 64 bits using

the IEEE floating point standard:
5.75 = 101.112 = 1.01112  22
+1023 "bias"
Try
practice
exercises
on course
exponent schedule

(11 bits)
0 10000000001 01110000000000000000000000000000000000000000000000000

sign mantissa
float (single precision):
(1 bit) bias = 127; exponent: 8 bits (52 bits) 21
mantissa: 23 bits
Problem: Binary representations of most real numbers
do not terminate; e.g.,
13.1 = 1101.00011001100110011…
So they can't be stored exactly; error in this
representation is called roundoff error.
Execution:
//-- Effect of roundoff error
0 0
0.1 0.104873
#include <iostream>
0.2 0.218968
#include <cmath>
. . .
using namespace std;
22.6 14.7859
22.7001 13.4103
int main()
22.8001 11.9884
{
. . .
for (double x = 0; x != 50.0; x = x + 0.1)
49.9998 42.937
{
50.0998 45.7826
doouble y = x * sqrt(1 + sin(x));
50.1998 48.5246
cout << x << " " << y << '\n';
. . .
//if (x > 60) break;
100.099 76.3241
}
. . .
}
Patriot missile failure
22
See Other Course Information
/* 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 <iostream> // 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"; 23
}
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
24
and it's my own initialization."
 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: 0xbfe0b82c int age: 0012FF60

int idNumber: 0xbfe0b828 int idNumber: 0012FF54
int x: 0xbfe0b824 int x: 0012FF48
int y: 0xbfe0b820 int y: 0012FF3C
double celsius: 0xbfe0b818 double celsius: 0012FF2C
double kelvin: 0xbfe0b810 double kelvin: 0012FF1C
double fahrenheit: 0xbfe0b808 double fahrenheit: 0012FF0C
char letterGrade: 0xbfe0b807 char letterGrade: 0012FF03
char a: 0xbfe0b806 char a: 0012FEF7
char b: 0xbfe0b805 char b: 0012FEEB
char c: 0xbfe0b804 char c: 0012FEDF
bool ok: 0xbfe0b803 bool ok: 0012FED3
bool done: 0xbfe0b802 bool done: 0012FEC7
bool d: 0xbfe0b801 bool d: 0012FEBB
bool e: 0xbfe0b800 bool e: 0012FEAF
Press any key to continue . . .
Unix/Linux Visual C++ A
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): *

B
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

C
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

D
 INT_MAX = 2147483647
INT_MIN = -2147483648
UINT_MAX = 4294967295
SHRT_MAX = 32767
SHRT_MIN = -32768
LONG_MAX = 2147483647
#include <iostream> LONG_MIN = -2147483648
#include <climits> CHAR_MAX = 127
#include <cfloat> CHAR_MIN = -128
using namespace std; FLT_MAX = 3.40282e+038
FLT_MIN = 1.17549e-038
int main() DBL_MAX = 1.79769e+308
{ DBL_MIN = 2.22507e-308
cout << "INT_MAX = " << INT_MAX << endl LDBL_MAX = 1.79769e+308
<< "INT_MIN = " << INT_MIN << endl LDBL_MIN = 2.22507e-308
<< "UINT_MAX = " << UINT_MAX << endl FLT_EPSILON = 1.19209e-007
<< "SHRT_MAX = " << SHRT_MAX << endl DBL_EPSILON = 2.22045e-016
<< "SHRT_MIN = " << SHRT_MIN << endl LDBL_EPSILON = 2.22045e-016
<< "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;
}
E
#include <iostream> 0 0
#include <cmath> 0.01 0.0100499
0.02 0.020199
using namespace std; 0.03 0.0304466
0.04 0.0407919
int main() 0.05 0.0512342
{ 0.06 0.0617727
0.07 0.0724066
for (double x = 0; x != 50.0; x = x + .01) 0.08 0.0831352
{ 0.09 0.0939575
double y = x * sqrt(1 + sin(x)); 0.1 0.104873
0.11 0.115881
cout << x << " " << y << endl; 0.12 0.12698
} .
.
} .
4.33 1.16366
4.34 1.1362
4.35 1.10858
4.36 1.08078
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
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
.
.
. F