2. What is in a Word?
• A byte is the basic addressable unit
of memory in RAM
Typically it is 8 bits (octet)
But some machines had 7, or 9, or ...
• A word is the basic unit of operation
by the CPU
– Most registers are this size
– Largest unit of transfer between RAM
and CPU in single instruction
3. What is a Type?
• A type is a qualifier that is used by
the compiler
Machine languages do not have types
• The type of a variable or constant
tells the compiler:
– How much space the object occupies
– What operations on the object mean
4. What is a Type?
• Given an address in RAM, what does
it mean?
Could be anything!
• Types tell the compiler
– Which instruction to apply
Integer addition, floating pt addition
– How to increment pointers
Array references, fields
5. Arithmetic Types in C++
Type Meaning Minimum Size
bool Boolean NA
char character 8 bits
wchar_t wide character 16 bits
short short integer 16 bits
int integer 16 bits
long long integer 32 bits
long long very long integer 64 bits
float 1-prec. floating point 6 (7) sig. digits
double double-prec. FP 10 (16) sig. digits
some
6. Which Type to Use?
• General Usage
– int – most integer arithmetic
– double – for floating point computation
char – only for chars
bool – only for Booleans
• Unsigned
– Used to save space – who cares?
– Do not mix signed and unsigned!
– Can cause headaches easily - avoid
7. Type Conversion
• Casting, or conversion
– Needed when different type expected
– Compiler handles automatically
• Bool
– LHS = {false if 0, true if non-0}
– RHS = {0 if false, 1 if true}
8. Type Conversion
• Integer ↔ Floating point number
– Truncate FPN when int on LHS
– Fractional part 0 when int on RHS
Can lose precision
• Out-of-Range
– LHS unsigned, then residue mod size
– LHS signed, then undefined (bad)
9. What is a Literal?
• A literal is a fixed, explicit value that
is known at compile time
– Can be used to initialize variables
– Can be used to initialize constants
– Can be used in expressions
Generally bad programming style
• It may be int, char, bool, etc.
– 5, 5.0, -3, 'a', “a”, “Go Gators!”, 'n'
10. Special Characters
• Some characters are not printable
• Some characters have special meaning
to the language
• For these, we need escape sequences
– All start with backslash
– Some predefined: n newline
– Any by x where x is a number
11. Special Characters
newline n horizontal tab t alert (bell) a
vertical tab v backspace b double quote ”
backslash question mark ? single quote '
carriage return r form feed f
Can use as single character:
std::cout << 'n'; std::cout << “tHello!n”;
Generalized escape sequence:
12 = 014 = x0c = newline in decimal, octal, hex
Note: only the first 3 octal digits are accepted
Note: hex uses all the following digits (!)
12. Special Literals
• Boolean
true
false
• Pointer
– nullptr ← preferred literal
– 0
– NULL (must #include cstdlib)
– Never any other
13. Variables
• A variable is a logically named, typed,
structured piece of storage
• Name allows us to refer to the stored
structure
• Type allows us to know structure
• Variables can be assigned new values
• Program can manipulate them!!
14. Variables
• Definition: allocates space for storage
• Declaration: specifies name and type
– So variable can be referenced here
– … and defined elsewhere
• Type var_name, var_name, …;
• All vars have type given at start
• Good practice: one per line of code!
15. Variable Definition
int sum = 0, value, // all type int
total = 0; /* sum and total
initialized to 0 */
Sales_item item; /* type Sales_item
initialized to
default value */
std::string name(“Dr. Newman”);
/* string is a type
from std library
variable length
character sequence */
16. Initialization
• Good idea: ALWAYS INITIALIZE!!!!
• Initialization – object gets value at
time of definition (when created)
– May be any expression that can be
evaluated at time of creation
– Name becomes visible immediately
– Hence can be used in subsequent
initializations in same line!
17. Variable Initialization
int i = 0, j = 2*i; /* j init uses value
of i immediately */
int k = sizeof(double); /* value is
a function that can
be evaluated when k
is defined */
18. “List” Initialization
int i = 0; /* i initialized with
literal value */
int i(0); /* here also */
int i = {0}; /* i initialized with
literal value, but
restricted */
int i{0}; /* same here */
double pi = 3.14;
int a{pi},
b = {pi};
int c(pi),
d = pi;
/* floating pt */
/* fail - requires
narrowing */
/* OK, but value …
… truncated */
19. Declaration vs. Definition
• Definition – allocate space
• Declaration – state type and name
– Name can be used in current file
– “Makes promise” it will be defined later
– Only define in ONE file
extern int i; /* declares but doesn't
define i*/
int j; // declares and defines j
20. Identifiers
• Identifier = name – for variable,
function, constant, class, type, etc.
• Cannot be a keyword in C++
• Identifiers may be composed of
letters, digits, and underscore char
– Must begin with _ or letter
• Identifiers are case-sensitive
– Main is not main is not MAIN!
24. Identifier Conventions
• Identifier should hint toward purpose
• Constants are all upper case
• Variables are lower case
• Classes start with upper case
• Multi-word identifiers should
distinguish each word using a capital
or underscore
– Sales_item, booksSold, totalRbis
25. Scoping
• When is a name visible/usable?
• Most scopes delimited by {} blocks
• Names can be reused across scopes
• Global scope – defined outside a fcn
• Block scope – accessible from point
defined onward within block
• Nested scopes – name visible in outer
scope can be redefined in inner scope
