Chapter 15 - Arrays and Pointers

1. Chapter 15 - Arrays and Pointers

2. Lab 8 – Etch-a-Sketch • An analog-to-digital converter converts continuous analog signals to discrete digital numbers. • Jitter is the physical phenomenon that results from "noise" associated with a analog signal. • manifests itself by the return values "dancing around“ • Eliminate noise and smooth out input data using • A lowpass filter... • Oversampling... • Thresholds... Arrays and Pointers

3. Lab 8 – Etch-a-Sketch • Digital equivalent of an analog low pass RC filter unsigned int lowpass_filter(unsigned int input, unsigned int* delay) { // Update filter with current sample. *delay = *delay - (*delay >> FILTER_SHIFT) + input; // Scale output for unity gain. return *delay >> FILTER_SHIFT; } Arrays and Pointers

4. Lab 8 – Etch-a-Sketch • Digital equivalent of an analog low pass RC filter delay_element += Input – (delay_element >> 4)) Arrays and Pointers

5. Lab 8 – Etch-a-Sketch #define FILTER_SHIFT 3 // Parameter K // initial lowpass filter delay values oldx = ADC_read(LEFT_POT); oldy = ADC_read(RIGHT_POT); pot1_delay = (oldx << FILTER_SHIFT) + (oldx >> FILTER_SHIFT);; pot2_delay = (oldy << FILTER_SHIFT) + (oldy >> FILTER_SHIFT);; while(1) { // pass through low-pass filter x = lowpass_filter(ADC_read(LEFT_POT), &pot1_delay); y = lowpass_filter(ADC_read(RIGHT_POT), &pot2_delay); } unsigned int lowpass_filter(unsigned int input, unsigned int* delay) { // Update filter with current sample. *delay += input - (*delay >> FILTER_SHIFT); // Scale output for unity gain. return (*delay >> FILTER_SHIFT); } Arrays and Pointers

6. Concepts to Learn… • Arrays • C Strings • Array Arguments • Pointers • Pointer Arithmetic • Swap Example w/Pointers • Null Pointers • Arrays and Pointers • Pointers to Pointers • Multi-dimensional Arrays • Command-line Arguments • Function Pointers Arrays and Pointers

7. Arrays Arrays • Allocate a sequence of memory locations. • For example - table of numbers • Problems • What if there are 1000 numbers? • Write a loop to process each number? • Use an array • Declare a sequence of four integers. • int num[4]; • num[0], num[1], num[2], num[3]. • An array is a sequence of like items. int num0;int num1;int num2;int num3; Arrays and Pointers

8. Arrays Array Syntax • Like any other variable, arrays must be declared before they are used. • General form: type variable-name[number_of_elements]; • The array size must be explicit at compile time – needed to reserve memory space • Array elements individually accessed. • General form: variable-name[index]; • Zero based subscripts • No compile-time or run-time limit checking Arrays and Pointers

9. Arrays Initialization of Arrays • Elements can be initialized in the same way as the ordinary variables when they are declared. • type array_name[size]={ list of values }; int number[3] = {0, 0, 0}; • Remaining uninitialized elements will be set to zero automatically. • Array declarations may omit the size. int counter[] = {1, 1, 1, 1}; • Problems with C initialization of arrays • No convenient way to initialize selected elements. • No shortcut to initialize large number of elements. Arrays and Pointers

10. Arrays Local Array Example SP  int main() { int array[10]; int x; x = array[3] + 1; array[6] = 5; return 0; } main: 0x87a2: 8031 0016 SUB.W #0x0016,SP 0x87a6: 431F MOV.W #1,R15 0x87a8: 511F 0006 ADD.W 0x0006(SP),R15 0x87ac: 4F81 0014 MOV.W R15,0x0014(SP) 0x87b0: 40B1 0005 000C MOV.W #0x0005,0x000c(SP) 0x87b6: 430C CLR.W R12 0x87b8: 5031 0016 ADD.W #0x0016,SP 0x87bc: 4130 RET Arrays and Pointers

11. Arrays Local Array Example SP  int main() { int array[10]; int x; for (x = 0; x < 10; x++) { array[x] = x; } return 0; } main: 0x8040: 8031 0016 SUB.W #0x0016,SP 0x8044: 4381 0014 CLR.W 0x0014(SP) 0x8048: 90B1 000A 0014 CMP.W #0x000a,0x0014(SP) 0x804e: 340D JGE (C$DW$L$main$2$E) C$DW$L$main$2$B, C$L1: 0x8050: 411F 0014 MOV.W 0x0014(SP),R15 0x8054: 5F0F RLA.W R15 0x8056: 510F ADD.W SP,R15 0x8058: 419F 0014 0000 MOV.W 0x0014(SP),0x0000(R15) 0x805e: 5391 0014 INC.W 0x0014(SP) 0x8062: 90B1 000A 0014 CMP.W #0x000a,0x0014(SP) 0x8068: 3BF3 JL (C$L1) C$L2, C$DW$L$main$2$E: 0x806a: 430C CLR.W R12 0x806c: 5031 0016 ADD.W #0x0016,SP 0x8070: 4130 RET Arrays and Pointers

12. Arrays Global Array Example int array[10]; int x; int main() { for (x = 0; x < 10; x++) { array[x] = x; } return 0; } main: 0x806a: 4382 0214 CLR.W &x 0x806e: 90B2 000A 0214 CMP.W #0x000a,&x 0x8074: 340C JGE (C$DW$L$main$2$E) C$DW$L$main$2$B, C$L1: 0x8076: 421F 0214 MOV.W &x,R15 0x807a: 5F0F RLA.W R15 0x807c: 429F 0214 0200 MOV.W &x,0x0200(R15) 0x8082: 5392 0214 INC.W &x 0x8086: 90B2 000A 0214 CMP.W #0x000a,&x 0x808c: 3BF4 JL (C$L1) C$L2, C$DW$L$main$2$E: 0x808e: 430C CLR.W R12 0x8090: 4130 RET Arrays and Pointers

13. Arrays Array Example SP  int array[10]; int x; grid[x+1] = grid[x] + 2; 0x86aa: 411F 0014 MOV.W 0x0014(SP),R15 0x86ae: 5F0F RLA.W R15 0x86b0: 510F ADD.W SP,R15 0x86b2: 432E MOV.W #2,R14 0x86b4: 5F2E ADD.W @R15,R14 0x86b6: 411F 0014 MOV.W 0x0014(SP),R15 0x86ba: 5F0F RLA.W R15 0x86bc: 532F INCD.W R15 0x86be: 510F ADD.W SP,R15 0x86c0: 4E8F 0000 MOV.W R14,0x0000(R15) Arrays and Pointers

14. C Strings C Strings • A C string is an array of characters: • char outputString[16]; • C strings are terminated with a zero byte. • C strings can be initialized when defined: • char outputString[] = "Text"; which is the same as: outputString[0] = 'T'; outputString[1] = 'e'; outputString[2] = 'x'; outputString[3] = 't'; outputString[4] = 0; • C has no string operators. • String functions in <string.h> library Compiler computes the size of the array (4 + 1 = 5 bytes) Arrays and Pointers

15. C Strings Strings are Arrays int main() { char string[] = "\nhello!"; printf("%s", string); } 0x61/0x0a  SP 0x6c/0x65 0x6f/0x6c 0x00/0x21 Arrays and Pointers

16. Array Arguments Passing Arrays as Arguments • C passes parameters to functions by value. • C passes the address of the 1st element by value. #define MAX_NUMS 5 int average(int values[]) { int i, sum = 0; for (i = 0; i < MAX_NUMS; i++) sum = sum + values[i]; return (sum / MAX_NUMS); } int main() { int nums[MAX_NUMS] = { 1, 2, 3, 4, 5 }; int mean = average(nums); return 0; } 0x05f2 SP  5 15 1 SP  2 3 4 5 3 Arrays and Pointers

17. Pointers

18. Pointers Pointers • A pointer is a variable that contains an address. • With pointers • functions can indirectly access variables. • functions can modify the arguments passed by the caller function. • sophisticated data structures can grow and shrink at run-time. • Arrays and pointers are closely related. • Array pointers enable us to conveniently process groups of data such as vectors, lists, and strings. Arrays and Pointers

19. Pointers Swap Function Example int main() { int a = 3; int b = 4; swap(a, b); } void swap(int a, int b) { int temp = a; a = b; b = temp; } Stack after call to swap(): 4 a 3 b swap temp 3 Return Adr main Arrays and Pointers

20. Pointers Pointer Variables • Pointer variables contain memory addresses. • Associated with a pointer variable is the type of value to which it points. • The asterisk (*) indicates that the following identifier is a pointer variable. • The ampersand (&) returns a pointer (address) to the following identifier. Pointer examples: int* ptr; char* cp; double* dp; int** p_ptr = &ptr; char *strings[10]; Arrays and Pointers

21. Pointers Syntax for Pointer Operators • A pointer variable is declared with the asterisk operator (*) type *var; // same - whitespace doesn’t matter type* var; • Dereferencing any expression returns a value *var returns contents of the memory location pointed to by var **var returns contents of the memory location pointed to by the memory location pointed to by var *3 returns the contents of memory location 3 • A pointer is created with the reference operator (&) &var • Reference must be applied to a memory object • &3 is illegal as it would return a pointer to a constant Arrays and Pointers

22. 0x05fa 0x05fc Pointers Pointers int *ptr1; int *ptr2; int i = 4; int j; ptr1 = &i; ptr2 = &j; // What will these print? printf("\n%04x", ptr1); printf("\n%04x", ptr2); printf("\n%04x", *ptr1); printf("\n%04x", *ptr2); j = *ptr1; printf("\n%04x", j); 4 4 0x05fa 0x05fc 0x0004 ?????? 0x0004 Arrays and Pointers

23. * =dereference & = reference Pointers Operator Precedence and Associativity Arrays and Pointers

24. Pointer Arithmetic Pointer Arithmetic • Address calculations depend on size of elements • ints are 16-bits or 2 bytes per element. • e.g., to find 4th element, we add 4*2 to base address • If double, we'd have to add 16 (4*4) to find address of 4th element. • C does size calculations under the covers,depending on size of item being pointed to: double x[10]; double *y = x; *(y + 3) = 13; Allocates 40 bytes (4 per element) Same as x[3] (base address plus 12) Arrays and Pointers

25. Pointer Arithmetic Incrementing Pointers • A pointer increments according to its type. • The unary operators * and & bind more tightly than arithmetic operators. int y = 0; int a[5] = {1, 5, 9, 13, 17}; int* ip = &a[0]; y = *ip + 1; *ip += 1; y = ++*ip; y = *ip++; y = (*ip)++; 1 5 9 // y=0, ip=0x05f2 // y = a[0]+1 y=2, ip=0x05f2 // a[0] = a[0]+1 y=2, ip=0x05f2 // a[0] = a[0]+1 y=3, ip=0x05f2 // ip = ip+1 y=3, ip=0x05f4 // a[1] = a[1]+1 y=5, ip=0x05f4 13 17 0x05f2 Arrays and Pointers

26. Pointer Arithmetic *ip++ • Form used by “experienced” C programmers // strcpy: copy s to d; version 1 void strcpy(char* d, char* s) { while ((*d = *s) != ‘\0’) { d++; s++; } } // strcpy: copy s to d; version 2 void strcpy(char* d, char* s) { while ((*d++ = *s++) != ‘\0’); } • The value of *s++ is the character that s pointed to before s was incremented; the postfix ++ does not change s until after this character has been fetched. Arrays and Pointers

27. Pointer Arithmetic Incrementing Pointers int main() { char *cptr; double *fptr; char buffer[10]; double array[10]; cptr = buffer; // cptr = &buffer[0]; fptr = array; // fptr = &array[0]; printf("\n0x%04d, 0x%04d", cptr++, fptr++); printf("\n0x%04d, 0x%04d", cptr, fptr); return 0; } 0x05cc, 0x05d6 0x05cd, 0x05da Arrays and Pointers

28. 3 4 Swap Example w/Pointers Swap Example Fixed! • Stack after call to swap() int main() { int a = 3; int b = 4; swap(&a, &b); } void swap(int* a, int* b) { int temp = *a; *a = *b; *b = temp; } 0x05fa a 0x05fc b swap temp 3 Return Adr main Arrays and Pointers

29. Null Pointers Null Pointers • Sometimes we want a pointer that points to nothing. • Used for invalid pointer error returns • Used to catch errors • NULLis a predefined macro that contains a value that non-null pointer should never hold, usually NULL=0. int *p; p = NULL; /* p is a null pointer */ Arrays and Pointers

30. Pointers and Arrays

31. Arrays and Pointers Arrays and Pointers • An array name is essentially a pointer to the first element in an array. • Can change the value (contents) of a pointer. char word[10]; char *cptr; cptr = word; // points to word[0] Arrays and Pointers

32. Arrays and Pointers Arrays and Pointers • Given the previous declarations, each of the following lines are equal. char word[10]; char *cptr; cptr = word; // points to word[0] cptr word &word[0] address of word[0] (cptr + n) word + n &word[n] address of word[n] *cptr *word word[0] value of word[0] *(cptr + n) *(word + n) word[n] value of word[n] Arrays and Pointers

33. Arrays and Pointers Array Pointer Arithmetic • Address calculations depend on size of elements • char x[4] – add 4 to base address • int x[4] – add 8 (2*4) to base address • long x[4] – add 16 (4*4) to base address • C does size calculations behind the scenes, depending on type of pointer (size of item being pointed to) long x[10]; // allocates 40 bytes long *y = x; *(y + 3) = 13; // same as x[3] = 13 Arrays and Pointers

34. Arrays and Pointers Common Pitfalls with Arrays • Overrun array limits. • There is no boundary checking in C. int array[10], i; for (i = 0; i <= 10; i++) // oops array[i] = 0; • Arrays must be statically declared • Compiler flags run-time declarations void SomeFunction(int num_elements) { int temp[num_elements]; // error … } Arrays and Pointers

35. Arrays and Pointers Initialization of Pointer Arrays • Pointer arrays can be initialized as follows: /* month_name: return name of n-th month */ char* month_name(int n) { static char* name[ ] = { "Illegal month", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; return ( n < 1 || n > 12 ) ? name[0] : name[n]; } Arrays and Pointers

36. Pointers and More…

37. linesptr[0] defghi linesptr[1] lmnopqrstuvwxyz linesptr[2] abc … Pointers to Pointers Pointers to Pointers • Since pointers are variables themselves, they can be stored in arrays just as other variables can. Example: char* linesptr[8]; Arrays and Pointers

38. linesptr[0] linesptr[1] linesptr[2] … Pointers to Pointers Pointers to Pointers • Since pointers are variables themselves, they can be stored in arrays just as other variables can. Example: char* linesptr[8]; defghi lmnopqrstuvwxyz abc Arrays and Pointers

39. Multi-dimensional Arrays Multi-dimensional Arrays • Multi-dimensional arrays declared with multiple indexes • daytab[i][j] /* [row][col] */ • daytab[i,j] /* WRONG! */ • Array elements are stored by rows • The rightmost subscript varies the fastest • Array name “points” to 1st element • Multi-dimensional arrays passed to a function must declare the number of elements for every subscript except the first • func(int daytab[ ][13]) {…} Arrays and Pointers

40. Command-line Arguments Command-line Arguments • When main is called, it is passed two arguments. • The first (conventionally called argc, for argument count) is the number of command-line arguments the program was invoked with. • The second (argv, for argument vector) is a pointer to an array of character pointers (strings) that contain the arguments, one per string. • By conventions, argv[0] points to the name by which the program was invoked. • By standards, argv[argc] is a null pointer. Arrays and Pointers

41. argv: echo\0 hello\0 world\0 Command-line Arguments Command-line Arguments • By standards, argv[argc] is a null pointer. /* echo command-line arguments int main(int argc, char* argv[ ]) { while (--argc > 0) printf("%s%s", *++argv, (argc > 1) ? " " : ""); printf("\n"); return 0; } Arrays and Pointers

42. Function Pointers Function Pointers • In C, a function is not a variable, but it is possible to define pointers to functions which can be: • assigned, • placed in arrays, • passed to functions, • returned by functions, and so on. int function1(int a, char* s) { … } int function2(int a, char* s) { … } int (*f[2])(int, char*); f[0] = function1; f[1] = function2; (*f[n])(10, "hello"); Arrays and Pointers

43. Function Pointers Complicated Declarations • C is sometimes castigated for the syntax of declarations, particularly ones that involve pointers to functions: int *f(); // f: function returning pointer to int int (*pf)(); // pf: pointer to function returning int • What do these do? char **argvargv: pointer to pointer to char int (*daytab)[13]daytab: pointer to array[13] of int int *daytab[13]daytab: array[13] of pointer to int char (*(*x())[])()x: function returning pointer to array[ ] of pointers to function returning char char (*(*x[3])())[5]x: array[3] of pointer to function returning pointer to array[5] of char Arrays and Pointers

44. Arrays and Pointers