1 / 21

Homework

Homework. Continue with K&R Chapter 5 Skipping sections 5.7-5.9 for now Not covering section 5.12. 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: pa - pb? 3

roy
Download Presentation

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

  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: pa - pb? 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. If they are of different types, you need to cast. pa = pb; • Add or subtract a pointer and an integer or an integer variable: pa + 3 pa – 5 pa + i /* i has a type int */ • 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

  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: no adding of pointers pa = pa + (pa-pb); YES: (pa-pb) is an integer s[4] = (cp < pa)? 'a': 'b'; NO: not members of same type 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 pointed to by a[0] */ *(*(a + 5) + 2) /* Third char in string pointed 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 on p.108: • 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. ptr (0xffff dc30) 0xffff dc5d Demo Program for pointer to pointer 0xffff dc6d cheungr@vm71:$ gdb p2p_example .. (gdb) b main Breakpoint 1 at 0x804840d: file p2p_example.c, line 3. (gdb) r Starting program: /home/cheungr/personal/p2p_example …. 0xffff dc30 ptr2ptr (0xffff dc58) cheungr@vm71:$ cat -b p2p_example.c 1 /* Example to show pointer to pointer */ 2 #include <stdio.h> 3 main(){ 4 char a[]={"Sun is shinning"}; 5 char b[]={"Moon is bright"}; 6 char * ptr[10]; 7 char ** ptr2ptr; 8 9 ptr[0] = a; 10 ptr[1] = b; 11 ptr2ptr = ptr; 12 } …. a (0xffff dc5d) ‘S’ Breakpoint 1, main () at p2p_example.c:3 3 main(){ (gdb) s 4 char a[]={"Sun is shinning"}; (gdb) s 5 char b[]={"Moon is bright"}; (gdb) s 9 ptr[0] = a; (gdb) s 10 ptr[1] = b; (gdb) s 11 ptr2ptr = ptr; (gdb) p/x &a[0] $1 = 0xffffdc5d (gdb) p/x &b[0] $2 = 0xffffdc6d (gdb) p/x &ptr[0] $3 = 0xffffdc30 (gdb) p/x ptr $4 = {0xffffdc5d,0xffffdc6d,0xffffdc8c,0xf7fcaff4,0x8048490,...} (gdb) s 12 } (gdb) p/x &ptr2ptr $5 = 0xffffdc58 (gdb) p/x ptr2ptr $6 = 0xffffdc30 (gdb) /x *ptr2ptr $7 = 0xffffdc5d (gdb) p/x *ptr2ptr++ $8 = 0xffffdc5d (gdb) p/x *ptr2ptr $9 = 0xffffdc6d …. ‘M’ b (0xffff dc6d) …. Memory Map

  10. 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 f \0 a b c \0 k l m \0

  11. Pointers to Pointers • To initialize the array with fixed values char a[] = “klm”; char b[] = “abc”; char c[] = “def”; lineptr[0] = a; /* or = &a[0]; */ lineptr[1] = b; /* or = &b[0]; */ lineptr[2] = c; /* or = &c[0]; */

  12. 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 f \0 a b c \0 k l m \0

  13. 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++]); }

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

  15. 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[ ]) • The value of argc is the number of char strings in the array argv[ ] which is an array of ptrs 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 main • If there are no other arguments, argc = 1

  16. Command-line Arguments • If there are other arguments: • For example, if the program was compiled as echo, and the user typed echo hello, world • argc will be 3 (the number of strings in argv[]) • argv[0] points to the beginning address of “echo” • argv[1] points to the beginning address of “hello,” • argv[2] points to the beginning address of “world”

  17. 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; }

  18. 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:

  19. 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; }

  20. Parsing Arguments • How does (*++argv)[0] and *++argv[0] differ? (*++argv)[0] • Increments pointer to argv[] array • De-reference the pointer and get the resulting pointer to the string • De-reference the pointer to the string and obtain the ascii value (‘h’) of the first character in the string *++argv[0] • De-reference argv and obtain the pointer to the string • Increment the resulting pointer and it points to the second position of the string • De-reference the pointer to get the ascii value ‘c’

  21. ‘h’ ‘e’ ‘c’ ‘e’ ‘h’ ‘l’ ‘o’ ‘l’ ‘’\0’’ ‘o’ ‘\0’ ‘w’ ‘o’ ‘r’ ‘l’ ‘d’ ‘\0’ Difference Between (*++argv)[0] and *++argv[0] argv[0] *++argv[0]=‘c’ argv argv[0] (*++argv) argv[1] argv[2] (*++argv)[0]= ‘h’

More Related