1. Starting Chapter 2 K&R. Read ahead.

2. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on the stack. (Note: Stack pointer is a register) foo(i, j); void foo(int i, int j) { } Stack Pointer Before call and after return Unused Stack Pointer After call and before return Unusedij Return Data Stack Data Stack Data Copy of Value

3. This is known as Call by Value. Unlike some languages, which have call by reference You can't change arguments in original location within the function -- just change the stack copy To make changes, you must pass pointers to original variables. See next slide. You’re not responsible for pointers yet, but start getting used to them! Call by Value vs Call by Reference

4. Pointers as Arguments Pointer variables passed as function parameters in C are still only value on the stack but can be used to access original location indirectly foo(&i, &j); void foo(int *i, int *j) { } Stack Pointer Before call and after return Unused Stack Pointer After call and before return Unused &i&j Return Data Stack Data Stack Data Point to values

5. Pointers as Arguments The following doesn’t work!!! void exchgint (int a, int b) { int dummy; dummy = a; a = b; b = dummy; }

6. Pointers as Arguments Must be done with pointers!!! void exchgint (int *pa, int *pb) { int dummy; dummy = *pa; *pa = *pb; *pb = dummy; }

7. Pointers as Arguments An array name is automatically passed as a pointer You don't need to create a pointer yourself with the “address of” operator (&) int array1[10], array2[10]; foo(array1, array2); Unless you are passing a pointer to a specific array element (Remember printf in visitype?) foo(&array1[4*i], &array2[4*j]);

8. Scope of Variables – Local Automatic Each local variable of a function (inside { }) comes into existence only when it is called disappears when a return is performed. Local variables are said to be automatic. Memory is allocated on the stack after the calling sequence argument values Undefined (i.e. garbage) value unless explicitly initialized in the source code Initialization is done each time the function or block is entered (K&R P.85). Stack Pointer After local variables are allocated Stack Data Unusedij Return Data Local Variables

9. Scope of Variables – Local Static A local alternative to automatic is known as static. A static variable declared in a function is preserved in memory. Still local - can only be used inside { }. It is guaranteed to be initialized to zero if it is not initialized otherwise. If the static variable is initialized, it is done once before the program starts execution (K&R P.85). e.g., the seed of a random number generator so it will have memory from one invocation to the next and not always give the same random number. int rand( ){ static int seed = 1; /* initialize to 1 in the beginning and remember value between calls to rand */ }

10. Scope of Variables – Local Static Good for implementing a “Finite State Machine” –They allow a function to preserve its state value(s) But, be careful using local static variables!! –A function may behave differently when it is called with different values preserved in local static variables –Makes testing of a function more complex because you need to test its behavior with all possible values of any local static variables –Complex sequence of calls to function may be required to drive local static variables into desired test “state(s)”

11. Scope of Variables - External Alternative to local is known as external Look at maxline program on page 32 of K&R Variables declared ahead of/outside of all { }’s are available to all functions within the program load These are sometimes called “global variables” Can be used to pass data between functions Values are preserved like static local variables It is guaranteed to be initialized to zero If the external variable is initialized, it is done once before the program starts execution. Not a good idea to use them – Why not?

12. Scope of Variables - External Global variables are not a good idea because: –They can be accessed from anywhere. If their value gets corrupted, it is NOT easy to figure out what code in which function caused the corruption. –They make the functions dependent on their external environment instead of being able to stand alone using arguments to get their input values and a return value to pass back an output value. Software architecture/design standards for most projects will prohibit use of “global variables” or severely restrict their use. Don’t use them!!

13. Scope of Variables – External Static Another alternative known as external static No good examples that I see in K&R Static variables declared ahead of/outside of all { }’s are available to all functions within this file only These are very similar to OOP “class variables” Can be used to pass data between functions in file only Values are preserved like static local variables It is guaranteed to be initialized to zero If the external static variable is initialized, it is done once before the program starts execution. These are more acceptable than global variables

14. Examples of Scopes of Variables These examples are from p.342: “C Programming for Scientists and Engineers with Applications” by Rama Reddy and Carol Ziegler, Jones and Bartlett 2010.

15. Scope of Variables – Example #1 #include int main(){ int a=10; printf(“a=%d\n”, a); { int b=5; printf(“b=%d\n”, b); { int c=40; printf(“c=%d\n”,c); } return 0; } Scope of c Scope of b Scope of a 10 5 40

16. Scope of Variables – Example #2 #include int main(){ int x=10; printf(“x=%d\n”, x); { int x=5; printf(“x=%d\n”, x); { int x=40; printf(“x=%d\n”,x); } x=x+4; printf(“x=%d\n”,x); } x=x+15; printf(“x=%d\n”,x); return 0; } x=40 x=5+4x=10+15 If the same variable is defined inside and outside the block, the name inside the block will be referenced if the block is being executed. 10 5 40 9 25

17. Scope of Variables – Example #3 #include void func1(void); void func2(void); void func3(void); int main(){ int x=20; printf(“x=%d\n”, x); func1(); x=x+10; printf(“x=%d\n”, x); func2(); x=x+40; printf(“x=%d\n”,x); func3(); return 0; } int x; void func1(void){ x=5; printf(“In func1 x=%d\n”,x); return; } void func2(void){ int x=0; printf(“In func2 x=%d\n”, x); return; } void func3(void){ printf(“In func3 x=%d\n”, x); return ; } Scope of 1 st x Scope of 2 nd x Scope of 3 rd x 20 30 70 5 0 5

18. Scope of Variables – Example #4 #include void func1(void); void func2(void); int main(){ int x=5; printf(“x=%d\n”, x); func1(); x=x+5; printf(“x=%d\n”, x); func2(); x=x+5; printf(“x=%d\n”,x); return 0; } int x; void func1(void){ x=6; printf(“In func1 x=%d\n”,x); } void func2(void){ x=x+10; printf(“In func2 x=%d\n”, x); } Scope of x External storage class definition 5 10 15 6 16

19. Scope of Variables – Example #5 #include void func1(void); void func2(void); int main(){ extern int x; x=1; printf(“x=%d\n”, x); func1(); x=x+6; printf(“x=%d\n”, x); func2(); x=x+7; printf(“x=%d\n”,x); return 0; } int x; void func1(void){ printf(“In func1 x=%d\n”,x); x=5; } void func2(void){ x=x+10; printf(“In func2 x=%d\n”, x); } Scope of x File 2 File 1 1 1 11 21 28

20. Scope of Variables – Example #6 #include void func1(void); void func2(void); int main(){ extern int x; x=1; printf(“x=%d\n”, x); func1(); x=x+6; printf(“x=%d\n”, x); func2(); x=x+7; printf(“x=%d\n”,x); return 0; } int x; void func1(void){ x=5; printf(“In func1 x=%d\n”,x); } void func2(void){ int x=10; printf(“In func2 x=%d\n”, x); } Scope of x File 1 File 2 1 11 18 5 10

21. Data Types Finished K&R Chapter 1 / Now starting Chapter 2 Variable Names Data Types: –char –int –short int –long int –float –double

22. Variable / Symbolic Constant Names Rules for generating names: –All letters and digits are allowed –Uppercase and lower case letters are different –First character must be a letter –Underscore _ counts as a letter (useful for improving readability) –But, don’t begin variable names with _ (reserved for library routines)

23. Variable / Symbolic Constant Names (cont’d) Rules for generating names: –Internal - at least 31 characters are significant –External – e.g. function names: only count on 6 characters and a single case –Avoid using C keywords (if, else, int, float, etc.) –Choose variable names that are related to the purpose or use of the variable

24. Data Types char (character) char has 8 bits (stored in one byte in memory) unsigned: 0 ≤ char ≤ 2 8 -1 00000000 ≤ char ≤ 11111111 Overflow at 255(255 + 1 = 0) Underflow at 0(0 – 1 = 255) signed (if supported in the implementation): -2 7 ≤ char ≤ 2 7 -1 10000000 ≤ char ≤ 01111111 Overflow at 127 (127 + 1 = -128) Underflow at –128 (-128 – 1 = 127)

25. Data Types int (integer on our machines) int has 32 bits (stored in four sequential bytes in memory) unsigned: 0 ≤ char ≤ 2 32 - 1 0x00000000 ≤ char ≤ 0xffffffff Overflow at 4294967295(4294967295 + 1 = 0) Underflow at 0(0 – 1 = 4294967295) signed: -2 31 ≤ char ≤ 2 31 -1 0x80000000 ≤ char ≤ 0x7fffffff Overflow at 2147483647 (2147483647 + 1 = –2147483648) Underflow at –2147483648 (-2147483648 – 1 = 2147483647)

26. Data Types short int (short integer on our machines) short int has 16 bits (stored in two sequential bytes in memory) unsigned: 0 ≤ char ≤ 2 16 - 1 0x0000 ≤ char ≤ 0xffff Overflow at 65535(65535 + 1 = 0) Underflow at 0(0 – 1 = 65535) signed: -2 15 ≤ char ≤ 2 15 -1 0x8000 ≤ char ≤ 0x7fff Overflow at 32767 (32767 + 1 = –32768) Underflow at –32768 (-32768 – 1 = 32767)

27. Data Types long int (long integer on our machines – same as int) long int has 32 bits (stored in four sequential bytes in memory) unsigned: 0 ≤ char ≤ 2 32 - 1 0x0000 0000 ≤ char ≤ 0xffff ffff Overflow at 4294967295(4294967295 + 1 = 0) Underflow at 0(0 – 1 = 4294967295) signed: -2 31 ≤ char ≤ 2 31 -1 0x8000 0000 ≤ char ≤ 0x7fff ffff Overflow at 2147483647 (2147483647 + 1 = –2147483648) Underflow at –2147483648 (-2147483648 – 1 = 2147483647)

28. Data Types float –32-bits (stored in four sequential bytes in memory) –based on the IEEE 754 floating point standard + 1.f x 2 e 18 bits23 bits signexponent efraction f

29. Data Types float, double –Both represent numbers with fractional parts –“double” is a “float” with more precision –Don't do much with float or double in this course –Implementation is machine dependent: for our machine: float is 4 bytes double is 8 bytes Without a co-processor to do floating point computations, it takes a lot of computation time to do them in software. –Not often used in real time, embedded systems. –A cost versus performance tradeoff!

30. Numbering Systems Binary (no symbol to represent binary numbers) –Learn binary numbers using this game http://forums.cisco.com/CertCom/game/binary_game_page.htm Octal (Octal Constant is written 0dd…) OCTALBINARY OCTAL BINARY 00004 100 1001 5 101 2010 6 110 3011 7 111 Note: Can’t write a decimal value with a leading 0 digit – will be interpreted as octal zero

31. Numbering Systems Hex (Hex Constant is written 0xdd…) HEXBIN.HEXBIN.HEXBIN.HEXBIN. 00000 40100 81000 C1100 10001 50101 91001 D1101 20010 60110 A1010 E1110 30011 70111 B1011 F1111 NOTE: Memorize these translations DO NOT convert between binary and Hex or Octal by converting to decimal and back! Much harder!! Learn to group binary digits by 3 (for octal) or 4 (for hex) to convert

32. Examples of the Number System Decimal Octal Hex 31 --------> 037 -----------> 0x1f 128 -------->0200 ----------> 0x80

33. Numbering Systems char Data Type Constants ‘a’integer value in ASCII code for letter a ‘0’integer value in ASCII code for number 0 ‘\b’integer value in ASCII code for backspace ‘\ooo’octal value 000 – 377 (0 – 255 decimal) ‘\xhh’hex value 0x00 – 0xff (0 – 255 decimal) examples ‘a’ = 0x61 ‘0’ = 0x30 ‘\127’ = 0x57 ‘\x2b’ = 0x2b

34. Numbering Systems Other Data Type Constants 1234int 1234Llong int 1234ULunsigned long int 1234.double (because of decimal point) 1234.4Ffloat (because of the suffix) 1234e-2double (because of exponent)

35. Converting Decimal to Binary Divide the decimal number successively by 2 and write down the remainder in binary form: e.g. 117 10 1171 LSB (after divide by 2, remainder =1) 580 (after divide by 2, remainder =0) 291 (after divide by 2, remainder =1) 140 (after divide by 2, remainder =0) 71 (after divide by 2, remainder =1) 31 (after divide by 2, remainder =1) 11 (after divide by 2, remainder =1) 0 0 MSB Read UP and add any leading 0’s: 01110101 odd even

36. Converting Decimal to Hex Method 1: –Convert the decimal number to binary and group the binary digits in groups of 4 e.g. 117 10  0111 0101 2  75 16 Method 2 (shown in HW3): –Divide the decimal number successively by 16 and write down the remainder in hex form: 117 5 LSB (after divide by 16, remainder =5) 7 7 MSB (after divide by 16, remainder =7) –Read UP and add any leading 0’s: 0x75

37. Converting Binary to Decimal Treat each bit position n that contains a one as adding 2 n to the value. Ignore zeros because they can’t add anything to the value. Bit 0LSB 1 1(= 2 0 ) Bit 10 0 Bit 21 4(= 2 2 ) Bit 31 8(= 2 3 ) Bit 40 0 Bit 5132(= 2 5 ) Bit 60 0 Bit 7MSB0 0 Total45

38. Converting Hex to Decimal Treat each digit n as adding 16 n to the value. Ignore zeros because they can’t add anything to the value. Digit 0LSB 0 0 Digit 12 32 (= 2 * 16 1 ) Digit 2b 2816 (= 11 * 16 2 ) Digit 30 0 Digit 40 0 Digit 511048576 (= 1 * 16 5 ) Digit 60 0 Digit 7MSB0 0 Total1051424

39. Base for Integer Constants Designating the base for an integer constant If constant begins with either: 0x It is Hex with a-f as Hex digits 0XIt is Hex with A-F as Hex digits Otherwise, if constant begins with 0It is Octal Otherwise, it is decimal

40. Base for Character Constants Designating the base for a character constant If constant begins with either: ‘\x It is Hex with 0-9 and a-f as Hex digits ‘\XIt is Hex with 0-9 and A-F as Hex digits Otherwise, if constant begins with ‘\0It is Octal Otherwise, it is the ASCII code for a character ‘a’

41. Constants Character and Integer Constants are Signed! –Sign bit (MSB) not set ‘\x55’ equals an 8-bit quantity 01010101 when casted to an int, it equals 0000 … 01010101 0x55 equals a 32-bit quantity 0000 … 01010101 –Sign bit (MSB) set ‘\xaa’ equals an 8-bit quantity 10101010 when casted to an int, it equals 1111 … 10101010 0xaa equals a 32 bit quantity 0000 … 10101010 –Note: None of the ASCII codes (x00 - x7f) have sign bit set!

42. Signed (Default) Behavior Careful mixing modes when initializing variables! int i; (signed behavior is default) char c;(signed behavior is default) i = 0xaa;(== 000000aa) as intended i = ‘\xaa’;(== ffff ffaa) sign extends! c = ‘\xaa’;(== aa) as intended i = c; (==ffff ffaa) sign extends! char int Sign Bit Extension 1 11111111 1 0101010

43. Unsigned Behavior Careful mixing modes when initializing variables! unsigned int i; (must specify unsigned if wanted) unsigned char c;(must specify unsigned if wanted) i = 0xaa;(== 000000aa) as intended i = ‘\xaa’;(== ffffffaa) char sign extends! c = ‘\xaa’;(== aa) as intended i = c; (==0000 00aa) char sign not extended! char int Sign Bit Extension 1 11111111 1 0101010

44. Example to illustrate signed/unsigned types void copy_characters(void){ char ch; while ((ch =getchar()) != EOF) putchar(ch); } If getchar() == EOF, is this true? What happens if ch is defined as unsigned char? Is this true? Changing the declaration of ch into int ch; makes it work. yes No

45. One’s Complement Two’s Complement One’s Complement Character Arithmetic ~ is the one’s complement operator ~ flips the value of each bit in the data All zeroes become one, All ones become zero ~ ‘\xaa’ == ‘\x55’ ~10101010 == 01010101 Number anded with its one’s complement = 0 10101010 & 01010101 00000000

46. One’s Complement Two’s Complement Two’s Complement Character Arithmetic - is the two’s complement operator -flips the value of each bit in the data and adds 1 It creates the negative of the data value - ‘\x55’ == ‘\xab’ - 01010101 == 10101011 Number added to its two’s complement = 0 01010101 +10101011 (1) 00000000 (carry out of MSB is dropped)

47. Two Special Case Values char 0 (or zero of any length) -00000000 = 11111111 + 1 = 00000000 char -2 7 (or -2 n-1 for any length = n) -10000000 = 01111111 + 1 = 10000000

48. Bit Manipulation Bitwise Operators: ~ one’s complement (unary not) & and | or ^ xor (exclusive or) << left shift >> right shift Lots of possible Exam questions here!

49. Binary Logic Tables AND01 0 11 0 0 0 NOT 0 0 1 1 OR01 0 11 0 1 1 ADD01 0 1 0 Carry 1 0 1 1 XOR01 0 1 10 01 Operands Results

50. Bit Manipulation unsigned char n = ‘\xa6’; n 10100110 ~n 01011001 (1s complement: flip bits) n | ‘\x65’ 10100110 turn on bit in result if | 01100101 on in either operand 11100111

51. Bit Manipulations n & ‘\x65’10100110 turn on bit in result if |01100101 on in both operands 00100100 n ^ ‘\x65’10100110 turn on bit in result if |01100101 on in exactly 1 operand 11000011

52. Bit Manipulations n = ‘\x18’;00011000 (Remember n is unsigned) n << 100110000shift 1 to left (like times 2) n << 201100000shift 2 to left (like times 4) n << 410000000shift 4 to left (bits disappear off left end) n >> 200000110shift 2 to right (like / 4) n >> 400000001shift 4 to right (bits disappear off right end) Unsigned Right Shift 0

53. Bit Manipulations Right shift result may be different if n is signed! –If value of n has sign bit = 0, works same as last slide –If value of n has sign bit = 1, works differently!! char n = ‘\xa5’; (default is signed) n10100101(sign bit is set) n >>2 11101001 (bring in 1’s from left) Bringing in extra copies of the sign bit on the left is also called "sign extension" Signed Right Shift

54. Bit Manipulations For signed variable, negative value shifted right by 2 or 4 is still a negative value ‘\xa5’ =10100101 ‘\xa5’ >> 2 = 11101001 = ‘\xe9’ Same result as divide by 4 (2 2 = 4) But, this is not true on all machines See K&R pg. 49, lines 8-10.

55. Bit Manipulations When dividing a negative value –Different rounding rules than for positive value –Remainder must be negative - not positive Note that (-1)/2 = -1 Note that -(1/2) = 0

56. Forcing Groups of Bits Off Given char n, how to turn off all bits except the least significant 5 bits: n = n & ‘\x1f’ n = ‘\xa5’ 10100101 n & ‘\x1f’ 10100101 &00011111 turn off all bits 00000101except bottom 5 Called "masking" the bits -- only see bits on in result where 1's found in mask value

57. Forcing Groups of Bits Off x = x & ~077 (octal for a change) Sets least significant 6 bits in x to 0 Even if you don't know size of x (e.g. size of int) ~077 = ~00... 00111111 = 11... 11000000 of required size Extends itself with 1 bits on left for length of x

58. Forcing Groups of Bits On Given n, how to turn on the MS two bits (if already on, leave on). n = n | ‘\xc0’ n = '\xa5' n | '\xc0':10100101 |11000000 turn on MS 2 bits 11100101

59. “Encryption” with Exclusive Or Show that x ^ (x ^ y) == y char y =‘\xa5’10100101(plain text bits) char x =‘\x69’01101001(encryption key) x ^ y11001100(cipher text bits) x ^ (x ^ y)10100101(decrypted bits) Same as original value of y!

60. String Constants String constant: “I am a string.” –An array (a pointer to a string) of char values somewhere ending with NUL = '\0', the char with zero value. –"0" is not same as '0'. The value "0" can't be used in an expression - only in arguments to functions like printf(). Also have string functions: See pg. 241, Appendix B and B3, pg. 249 #include With these definitions, can use: len = strlen(msg); where msg is string in a string array NOTE: Write your own string functions for homework!!

61. Enumeration Symbolic Constants enum boolean {FALSE, TRUE}; –Enumerated names assigned values starting from 0 FALSE = 0 TRUE = 1 Now can declare a variable of type enum boolean: enum boolean x; x = FALSE; Just a shorthand for creating symbolic constants instead of with #define statements Storage requirement is the same as int

62. Enumeration Symbolic Constants If you define months as enum type enum months {ERR, JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC}; Debugger might print value 2 as FEB

63. Code Example of the enum type int main() { enum month {ERR, JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC}; enum month this_month; this_month = FEB; … }

64. const "const" declaration is like "final" in Java –warns compiler that variable value shouldn't change const char msg[ ] = "Warning:..."; –Commonly used for function arguments int copy(char to[ ], const char from[ ]); If logic of the copy function attempts to modify the “from” string, compiler will give a warning Exact form of warning and actual behavior of the code is installation defined

65. Operators Arithmetic Operators: +Add -Subtract *Multiply /Divide % Modulo (Remainder after division ) e.g. 5%7 = 5 7%7 = 0 10%7 = 3 Examples: int x, y; x / y truncates (no fractional part) x % y is the remainder when x is divided by y. Always true that: x == y*(x/y) + x%y

66. Operators Logical Operators: &&logical and ||logical or ! Not Example: … int year; if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) printf( "%d is a leap year\n", year); else printf( "%d is not a leap year\n", year); Why are no inner parentheses needed? See precedence table, P 53. Good questions for exams!!

67. Precedence and Associativity of Operators ( ) [ ] ->.Left to right ! ~ ++ - - + - * & (type) sizeofright to left * / %left to right + -left to right > left to right >=left to right = = !=left to right &left to right ^left to right |left to right &&left to right ||left to right ?:right to left = += -= *= /= %= &= ^= |= >=right to left,left to right Precedence signdereference addresscasting Associativity

68. Precedence and Associativity Precedence –Operators in the same row have the same precedence –Operators are in order of decreasing precedence Associativity –Determine the order if the operators have the same precedence –e.g x = y +=z -= 4 means x = y +=(z -= 4) x =(y +=(z -= 4))

69. Relations / Comparisons We call a comparison between two arithmetic expressions a "relation" ae1 =, > ) A relation is evaluated as true or false (1 or 0) based on values of given arithmetic expressions if ( i < lim-1 = = j < k) –What's it mean? –See precedence table P 53 Instead of c != EOF, could write !(c = = EOF)