1 / 22

Homework

Homework. Continue with K&R Chapter 5 Skipping sections 5.7-5.9 for now Not covering section 5.12 Continue on HW5. 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]

yoshe
Télécharger la présentation

Homework

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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. 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. 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 – pb Note: Result is an integer • Compare two pointers to members of same array: if (pa <= pb)

  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. 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. 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. 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. 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. Pointers to Pointers • Example of pointers to unsorted char strings char *lineptr[MAXLINES]; lineptr[0] lineptr[1] lineptr[2] lineptr[3] lineptr[4] . . . d e \0 a b c \0 k \0

  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. Pointers to Pointers • Examples of pointers to sorted char strings char *lineptr[MAXLINES]; lineptr[0] lineptr[1] lineptr[2] lineptr[3] lineptr[4] . . . d e \0 a b c \0 k \0

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

  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. 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’ ‘o’ ‘\0’ ‘h’ ‘e’ ‘l’ ‘l’ ‘o’ ‘,’ ‘\0’ ‘w’ ‘o’ ‘r’ ‘l’ ‘d’ ‘\0’

  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. 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. 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. 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. 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. Stack Frames for main() Recursion Stack Pointer argc argv • 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 [0]=“rmain” [1]=“3” Stack Pointer argc argv 2 2 Stack Pointer [0]=“” [1]=“2” [0]=“rmain” [1]=“3” argc argv 2 2 2 [0]=“” [1]=“1” [0]=“rmain” [1]=“3” [0]=“” [1]=“2”

  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)%

More Related