1. Basic Types, Variables, Literals, Constants

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++ TypeMeaningMinimum Size boolBooleanNA charcharacter8 bits wchar_twide character16 bits shortshort integer16 bits intinteger16 bits longlong integer32 bits long very long integer64 bits float1-prec. floating point 6 (7) sig. digits doubledouble-prec. FP 10 (16) sig. digits long doubleExtended-prec FP 10 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\nhorizontal tab\talert (bell)\a vertical tab\vbackspace\bdouble quote\” backslash\\question mark\?single quote\' carriage return\rform 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!

21. 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

22. 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

23. C++ Alternative Operator Names and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq

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