Basic Types, Variables,

Literals, Constants
 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
 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
 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
some
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
 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
 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}
 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)
 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'
 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
 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 (!)
 Special Literals

• Boolean
 true
 false
• Pointer
– nullptr ← preferred literal
– 0
– NULL (must #include cstdlib)
– Never any other
 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!!
 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!
 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 *
 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!
 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 */
 “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; /* floating pt */

int a{pi}, /* fail - requires
b = {pi}; narrowing */
int c(pi), /* OK, but value …
d = pi; … truncated */
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
 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!
 C++ Keywords
alignas constexpr extern
alignof const_cast false
asm continue float
auto decltype for
bool default friend
break delete goto
case do if
catch double inline
char dynamic_cast int
char16_t else long
char32_t enum mutable
class explicit namespace
const export new
 C++ Keywords
noexcept static_assert union
nullptr static_cast unsigned
operator struct using
private switch virtual
protected template void
public this volatile
register thread_local wchar_t
reinterpret-cast throw while
return true
short try
signed typedef
sizeof typeid
static typename
C++ Alternative Operator
Names
and compl or_eq
and_eq not xor
bitand not_eq xor_eq
bitor or
 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
 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