Basic Types, Variables, Literals, Constants

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 long double Extended-prec FP 10 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 backslash \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, total = 0; Sales_item item; // all type int /* sum and total initialized to 0 */ /* 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; 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; /* 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 alignof asm auto bool break case catch char char16_t char32_t class const 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 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 and_eq bitand bitor compl not not_eq or or_eq xor 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, 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