1. 1 Homework Continue with K&R Chapter 5 –Skipping sections 5.7-5.9 for now –Not covering section 5.12 Continue on HW5

2. 2 Review Pointers. int a[ ] ={1,3,5,7,9,11,13,15,17,19}; int *pa = &a[4],*pb = &a[1]; What is the value of: *(a + 2)?Same as a[2] What is the value of: pb - pa? Integer -3 What is the value of: pb[1]?Same as a[2] What is the effect of: *pa += 5?a[4] += 5 What is the effect of: *(pa += 2)?pa = &a[6], value is a[6] What is the effect of: *(a += 2)?Illegal, can't modify an array name such as a What is the value of: pa[3]? Same as a[9]

3. 3 Valid Pointer Arithmetic Set one pointer to the value of another pointer of the same type. pa = pb; Add or subtract a pointer and an integer: pa + 3 pa - 5 Subtract two pointers to members of same array: pa – pbNote: Result is an integer Compare two pointers to members of same array: if (pa <= pb)

4. 4 Valid Pointer Arithmetic Assign a pointer to zero (called NULL in stdio) pa = NULL; same as pa = 0; Compare a pointer to zero (called NULL in stdio) If (pa != NULL); BUT NOT if (pa > NULL) Note: a NULL pointer doesn't point to anything (When used as a return value, it indicates failure of a function that is defined to return a pointer) All other pointer arithmetic is invalid.

5. 5 Valid Pointer Arithmetic If we add new declarations to ones on slide #2, char s[ ] = "Hello, world!", *cp = &s[4]; Which assignments below are valid?: cp = cp - 3; YES pa = cp; NO (Possible alignment problem, int’s on 4 byte boundaries) pa = pa + pb; NO s[4] = (cp < pa)? 'a': 'b'; NO s[4] = (cp > 0)? 'a': 'b'; NO cp = NULL;YES

6. 6 Pointer Arrays, K&R 5.6 Recall that if we define char a[10]; We are setting aside space in memory for the elements of array a, but a can be treated as a pointer. We can write *a or *(a + 5). Now think about the declaration: char *a[10];

7. 7 Pointers to Pointers What does the array a contain now? Pointers to char variables or strings! Though hard to think about, we can write: **a/* First char in string ptd to by a[0] */ *(*(a + 5) + 2) /* Third char in string ptd to by a[5] */

8. 8 Pointers to Pointers Now what is the use of keeping an array of pointers to char strings? K&R gives an example: –Reading in a sequence of lines –Placing them in blocks of memory (e.g. malloc) –Building an array of pointers to the blocks –Sorting by moving pointers – not strings

9. 9 Pointers to Pointers Example of pointers to unsorted char strings char *lineptr[MAXLINES]; lineptr[0]lineptr[1]lineptr[2]lineptr[3]lineptr[4] de\0 abc... k\0

10. 10 Pointers to Pointers To initialize the array with fixed values char x[] = “k”; char y[] = “abc”; char z[] = “de”; lineptr[0] = x; /* or = &x[0]; */ lineptr[1] = y; /* or = &y[0]; */ lineptr[2] = z; /* or = &z[0]; */

11. 11 Pointers to Pointers Examples of pointers to sorted char strings char *lineptr[MAXLINES]; lineptr[0]lineptr[1]lineptr[2]lineptr[3]lineptr[4] de\0 abc... k\0

12. 12 Pointers to Pointers Write out lines in pointer order (easy way) void writelines(char * lineptr[], int nlines) { int i = 0; while (i < nlines) printf("%s\n", lineptr[i++]); }

13. 13 Pointers to Pointers Write out lines in pointer order (efficiently) void writelines(char **lineptr, int nlines) { while (nlines-- > 0) printf("%s\n", *lineptr++); }

14. 14 Command-line Arguments, K&R 5.10 The main( ) function can be called with arguments Must declare them to use them: main (int argc, char *argv[ ]) OR main (int argc, char **argv) The value of argc is the number of char strings in the array argv[ ] which is an array of pointers to the command line tokens separated by white space Element argv[0] always points to the command name typed in by the user to invoke the program If there are no other arguments, argc = 1

15. 15 Command-line Arguments If the program was compiled as echo and the user types: echo hello, world argc will be 3 (the number of pointers in argv[]) argv[0]argv[1]argv[2]argv[3]argv[4] ‘e’‘c’‘h’‘\0’ ‘h’‘e’‘l’... ‘w’‘\0’ ?? ‘o’ ‘l’‘o’‘,’ ‘o’‘l’‘r’‘d’

16. 16 Command-line Arguments The program can print back the arguments typed in by the user following the echo command: int main (int argc, char *argv[ ]) { /* envision argc = 3, *argv[0]=“echo”, …*/ while (--argc > 0) printf("%s%s", *++argv, (argc > 1) ? " " : ""); printf("\n"); return 0; }

17. 17 Parsing Arguments Nice example given in Section 5.10. The program compiled with the run file name “find” looks for a pattern in standard input and prints out lines found. Want options -x and -n for invocation: find [-x] [-n] pattern OR find [-xn] pattern Program will parse option flags: except and number. Loop to parse options and set up flags is:

18. 18 Parsing Arguments Loop through argv entries with first char == '-' (maybe find -x -n pattern) while (--argc > 0 && (*++argv)[0] == '-') while (c = *++argv[0]) switch (c) { case 'x' : except = 1; break; case 'n' : number = 1; break; default : printf("illegal option %c\n", c);break; }

19. 19 Parsing Arguments How (*++argv)[0] and *++argv[0] differ? (*++argv)[0] –Pre-increments argv pointer (points to next string) –De-references pointer (to get pointer to string) –De-references pointer with 0 offset to get first character *++argv[0] –De-references argv pointer with 0 offset (first string) –Pre-increments argv[0] (points to next char in string) –De-references updated pointer to get second character

20. 20 Recursive Main Program int main(int argc, char *argv[ ])/* recursive main program */ { /* calculate factorial of arg[1]*/ char array[100]; char *nargv[2] = {"", array}; unsigned int i; if (argc != 2) return 0; if (!strcmp(argv[1], "1")) return 1; else { itoa(atoi(argv[1]) - 1, nargv[1]); i = atoi(argv[1]) * main(argc, nargv); printf("Returning: %d\n", i); return i; } }/* see Lecture 7 for function itoa – not in library */

21. 21 Stack Frames for main() Recursion UNIX shell calls main with: main (2, {“rmain”, “3”}); main calls main with: main (2, {“”, “2”}); main calls main with: main (2, {“”, “1”}); main returns 3 times 2 Stack Pointer Stack Pointer Stack Pointer 2 2 22 [0]=“rmain” [1]=“3” [0]=“” [1]=“2” 2 [0]=“” [1]=“1” argc argv [0]=“rmain” [1]=“3” [0]=“rmain” [1]=“3” [0]=“” [1]=“2”

22. 22 Recursive Main Program blade64(32)% gcc -o rmain rmain.c blade64(33)% rmain 10 Returning: 2 Returning: 6 Returning: 24 Returning: 120 Returning: 720 Returning: 5040 Returning: 40320 Returning: 362880 Returning: 3628800 blade64(34)%