Basic Types Variables Literals Constants What is in

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 character 8 bits wchar_t wide character 16 bits short integer 16 bits long integer 32 bits long very long integer 64 bits float 1 -prec. floating point 6 (7) sig. digits 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 \ carriage return r question mark ? single quote form feed f Can use as single character: std: : cout << 'n'; std: : cout << “t. Hello!n”; Generalized escape sequence: 12 = 14 = x 0 c = 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, …; • All vars have type given at start • Good practice: one per line of code!

Variable Definition int sum = 0, value, total = 0; // all type int /* sum and total initialized to 0 */ Sales_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; int i(0); int i = {0}; int i{0}; /* i initialized with literal value */ /* here also */ /* i initialized with literal value, but restricted */ /* 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 */

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; int j; /* declares but doesn't define i*/ // 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 alignof asm auto bool break case catch char 16_t char 32_t class constexpr const_cast continue decltype default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new

C++ Keywords noexcept nullptr operator private protected public register reinterpret-cast return short signed sizeof static_assert static_cast struct switch template this thread_local throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while

C++ Alternative Operator Names and_eq bitand bitor compl not_eq or or_eq xor_eq

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, books. Sold, total. Rbis

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 • • •