1. CSCI206 - Computer Organization & Programming
Introducing Pointers in C
zyBook: 9.1, 9.2
prelab for lab 7

2. Pointers Powerful feature of C.
Java/C++ “references” are pointers with extra safety checks.
In C the programmer is responsible.
* is the dereference operator, used to declare a pointer and access memory pointed to by a pointer.
& is the address of operator, it returns a pointer.

3. Pointers int i = 7; int j = -1; int* pi = &i; int *pj = &j;
printf(" i = %d\n", i);
printf(" j = %d\n", j);
printf(" pi= %p\n", pi);
printf(" pj= %p\n", pj);
printf(" data pointed to by pi= %d\n", *pi);
printf(" data pointed to by pj= %d\n\n", *pj);
*pi = 6;
declare and initialize pointers

4. Pointers int i = 7; int j = -1; int *pi = &i; int *pj = &j;
printf(" i = %d\n", i);
printf(" j = %d\n", j);
printf(" pi= %p\n", pi);
printf(" pj= %p\n", pj);
printf(" data pointed to by pi= %d\n", *pi);
printf(" data pointed to by pj= %d\n\n", *pj);
*pi = 6;
dereference the pointer to access the value it points to

5. Pointers compared to assembly
dereference (*pointer)
lw $t0, pointer or sw $t0, pointer
address of operator (&variable)
la $t0, variable

6. Pointers allow pass by reference
void addone(int i){
i = i + 1; }
void addone(int *i){
*i = *i + 1;
addone:
addi $a0, $a0, 1
jr $ra
lw $t0, 0($a0)
addi $t0, $t0, 1
sw $t0, 0($a0)
pass by copy
pass by ref

7. Pass by pointer
#include <stdio.h> #include <stdlib.h> void ConvFeetInches(int totDist, int inFeet, int inInches) {
inFeet = totDist / 12; inInches = totDist % 12; return; } int main(void) { int initMeasure = 45; int resFeet = 0; int resIn = 0; ConvFeetInches(initMeasure, resFeet, resIn); printf("%d feet %d inches\n", resFeet, resIn); return 0; }

8. Pass by pointer
#include <stdio.h> #include <stdlib.h> void ConvFeetInches(int totDist, int* inFeet, int* inInches) {
*inFeet = totDist / 12; *inInches = totDist % 12; return; } int main(void) { int initMeasure = 45; int resFeet = 0; int resIn = 0; ConvFeetInches(initMeasure, &resFeet, &resIn); printf("%d feet %d inches\n", resFeet, resIn); return 0; }

9. Pointers vs arrays
At the machine level, arrays are treated as pointers in C.
int arr[10];
assert(arr == &arr[0]); // TRUE
printf("%p\n", &arr[0]);
printf("%p\n", arr);
0x7ffcc7cdc500

10. Pointer Arithmetic int array[10] = {30,31,32,33,34,35,36,37,38,39};
int *ptr;
printf("Addr of array : %p\n", array);
printf("ptr holds addr: %p\n", ptr);
ptr = array;
printf("ptr holds addr: %p\n\n", ptr);
ptr = ptr + 1;
printf("Addr of arr[1]: %p\n", &(array[1]));
printf("ptr hold addr : %p\n", ptr);
printf("ptr points to : %d\n\n", *ptr);

11. Pointer Arithmetic ptr = ptr + 4; printf("ptr hold addr: %p\n", ptr);
printf("ptr points to: %d\n\n", *ptr);
ptr--; // or ptr -= 1;
double arr2[5] = {0.0, 0.5, , 2.71, 1.41};
double *ptr2;
ptr2 = arr2;
printf("ptr2 holds addr: %p\n", ptr2);
ptr2++;
printf("ptr2 holds addr: %p\n\n", ptr2);

12. C array with unknown size
This is often used to pass arrays into functions.
Does not allocate space for the array!
We don’t know input size at compile time.
Must pass size as another parameter or use a sentinel value.
Beginning of array is passed as a pointer.
int arr[]; // valid, same as int *arr
int *arr; // valid, same as above

13. Clear1 and Clear2
clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; }
clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; }

14. clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; }
move $t0,$zero # i = 0 loop1: sll $t1, $t0, # $t1 = i * add $t2, $a0, $t # $t2 = address of array[i] sw $zero, 0($t2) # array[i] = addi $t0, $t0, # i = i slt $t3, $t0, $a # $t3 = (i < size) bne $t3, $zero, loop1 # if (i < size) go to loop1
array access using indices requires multiply by 4 to convert index to array offset

15. clear2(int. array, int size) { int
clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; }
Clear2
move $t0, $a # p = address of array[0] sll $t1, $a1, # $t1 = size * add $t2, $a0, $t # $t2 = address of array[size] loop2: sw $zero, 0($t0) # Memory[p] = addi $t0, $t0, # p = p slt $t3, $t0, $t # $t3 = (p < &array[size]) bne $t3, $zero, loop2 # if (p < &array[size]) go to loop2
compute end address.
increment pointer by 4 to get next array element.

16. Clear3 clear3(int *array, int size) { while (size--){ *array++ = 0;
clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; }
clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; }
clear3(int *array, int size) { while (size--){
*array++ = 0;
} }
book
real world
Few C programmers would actually use a for loop like this, instead consider a while loop.

17. Pointers vs arrays
In assembly it is often easier to operate on pointers rather than arrays.
Avoids converting indexes to memory addresses.
However, this doesn’t mean operating on pointers in C is more efficient than arrays.
The compiler is very good at optimizing array access!
Array code can be more readable and less error prone!

18. Summary Pointers are just addresses of variables.
Pointers have types such that ptr ++ means different amount of increment, depending on the type of the pointer.