1. EPSII
59:006
Spring 2004

2. Announcements No TA Office Hours today (March 3) after 4:30 p.m.
Next homework assignment:
Will be posted on Friday, March 5
Due on Friday, March 12

3. Pointers Introduction Pointer Variable Declarations and Initialization
Pointer Operators
Calling Functions by Reference
Bubble Sort Using Call by Reference

4. Introduction Pointers Powerful, but difficult to master concept
Used for call-by-reference parameter passage
Close relationship with arrays and strings

5. Pointer Variable Declarations and Initialization
Pointer variables
Contain memory addresses as their values
Normal variables contain a specific value (direct reference)
Pointers contain address of a variable that has a specific value (indirect reference)
Indirection – referencing a pointer value
count 7
count 7
countPtr

6. Pointer Variable Declarations and Initialization
Pointer declarations
* used with pointer variables
int *myPtr;
Declares a pointer to an int (pointer of type int *)
Multiple pointers require using a * before each variable declaration
int *myPtr1, *myPtr2;
Can declare pointers to any data type
Initialize pointers to 0, NULL, or an address
0 or NULL – points to nothing (NULL preferred)

7. Pointer Operators & (address operator)
References the address of a variable
int y = 5;
int *yPtr;
yPtr = &y; // yPtr gets address of y
// yPtr “points to” y
yPtr y 5
yptr
500000
600000
Address of y is value of yptr

8. Pointer Operators * (indirection/dereferencing operator)
References the variable “pointed to” by a pointer variable
*yPtr refers to y (because yPtr points to y)
* can be used for assignment:
*yPtr = 7; // changes y to 7
Dereferenced pointer (operand of *) must be an lvalue (no constants)
* and & are inverses
They cancel each other out
That is: *&x == x

9. Pointers—A simple example
int main(void) {
float x, y;
float *p, *q; // p is of type “pointer to float”
p = &x; // assigns address of x to p -- i.e. p “points to” x
q = &y; // assigns address of y to q – i.e. q “points to” y
/* Now the following two statements are equivalent */
x = 7.0;
*p = 7.0;
/* and the following three statements are equivalent */
y = x;
y = *p;
*q = *p; }
Notes: Read &x as “the address of variable x”
Read *p as “the memory location pointed to by p” — i.e. x

10. Declare variables Initialize variables Print Program Output
1 /* Fig. 7.4: fig07_04.c
2 Using the & and * operators */
3 #include <stdio.h> 4
5 int main()
6 {
7 int a; /* a is an integer */
8 int *aPtr; /* aPtr is a pointer to an integer */ 9
10 a = 7;
11 aPtr = &a; /* aPtr set to address of a */ 12
13 printf( "The address of a is %p"
"\nThe value of aPtr is %p", &a, aPtr ); 15
16 printf( "\n\nThe value of a is %d"
"\nThe value of *aPtr is %d", a, *aPtr ); 18
19 printf( "\n\nShowing that * and & are complements of "
"each other.\n&*aPtr = %p"
"\n*&aPtr = %p\n", &*aPtr, *&aPtr ); 22
23 return 0;
24 }
Declare variables
Initialize variables
Print
Program Output
The address of a is the value of aPtr.
The * operator returns an alias to what its operand points to. aPtr points to a, so *aPtr returns a.
Notice how * and & are complements
The address of a is 0012FF88
The value of aPtr is 0012FF88
The value of a is 7
The value of *aPtr is 7
Showing that * and & are complements of each other.
&*aPtr = 0012FF88
*&aPtr = 0012FF88

11. Calling Functions by Reference
Call by reference with pointer arguments
Pass address of argument using & operator
Allows you to change actual location in memory
Arrays are not passed with & because the array name is already a pointer
* operator
Used as alias/nickname for variable inside of function
void double( int *number ) {
*number = 2 * ( *number ); }
*number used as nickname for the variable passed

12. Call-by Reference– A simple example
A function that swaps the value of two variables
First, a version that DOESN’T work:
void swap( int , int);
int main(void) {
int x = 3;
int y = 5;
printf(“x=%d y=%d\n”, x,y);
swap(x, y); }
void swap(int a, int b) {
int temp;
temp = a;
a = b;
b = temp;
swap has no effect on the
values of x and y due to
pass-by-value parameter
passage
x=3 y=5

13. Call-by-reference– a simple example
Now, a version of swap that works:
void swap( int *, int *);
int main(void) {
int x = 3;
int y = 5;
printf(“x=%d y=%d\n”, x,y);
swap(&x, &y); }
void swap(int *a, int *b) {
int temp;
temp = *a;
*a = *b;
*b = temp;
x=3 y=5
x=5 y=3

14. Function prototype Initialize variables Call function Define function
1 /* Fig. 7.7: fig07_07.c
2 Cube a variable using call-by-reference
3 with a pointer argument */ 4
5 #include <stdio.h> 6
7 void cubeByReference( int * ); /* prototype */ 8
9 int main()
10 {
11 int number = 5; 12
13 printf( "The original value of number is %d", number );
14 cubeByReference( &number );
15 printf( "\nThe new value of number is %d\n", number ); 16
17 return 0;
18 } 19
20 void cubeByReference( int *nPtr )
21 {
22 *nPtr = *nPtr * *nPtr * *nPtr; /* cube number in main */
23 }
Notice that the function prototype takes a pointer to an integer (int *).
Function prototype
Initialize variables
Call function
Define function
Program Output
Notice how the address of number is given - cubeByReference expects a pointer (an address of a variable).
Inside cubeByReference, *nPtr is used (*nPtr is number).
The original value of number is 5
The new value of number is 125

15. Bubble Sort Using Call-by-reference
Implement bubblesort using pointers
Swap two elements
swap function must receive address (using &) of array elements
Array elements have call-by-value default
Using pointers and the * operator, swap can switch array elements
Psuedocode
Initialize array
print data in original order
Call function bubblesort
print sorted array
Define bubblesort

16. Initialize array Declare variables Print array Call bubbleSort
Bubblesort is passed the address of array a. The name of an array is a pointer, so & is not
needed.

17. Function definitions Program Output
Could also have specified the
parameter as:
int array[ ]
33 int pass, j;
34 for ( pass = 0; pass < size - 1; pass++ ) 35
for ( j = 0; j < size - 1; j++ ) 37
if ( array[ j ] > array[ j + 1 ] )
swap( &array[ j ], &array[ j + 1 ] );
40 } 41
42 void swap( int *element1Ptr, int *element2Ptr )
43 {
44 int hold = *element1Ptr;
45 *element1Ptr = *element2Ptr;
46 *element2Ptr = hold;
47 }
Data items in original order
Data items in ascending order