Eastern Mediterranean University School of Computing and Technology Information Technology Lecture4 Pointers

Transcription

1 Eastern Mediterranean University School of Computing and Technology Information Technology Lecture4 Pointers Pointers, Addresses and Dereferencing What is a pointer? What is a memory address? What does dereferencing a pointer mean? A pointer is a variable that holds the location of, literally the address-of, a variable stored in computer memory. An address is the actual address-of a variable in the computer memory. Dereferencing a pointer means getting the value stored in the memory at the address which the pointer points to. The * is the value-at-address operator, also called the indirection operator. It is used both when declaring a pointer and when dereferencing a pointer. I will show why it is helpful to read it as the value-at-address operator in the code below. When we talk about getting the value-at-addess of the pointer we are talking about getting the value stored in the memory at the address which the pointer points to. The & is the address-of operator and is used to reference the memory address of a variable. When we declare a variable, three things happen. One, computer memory is set aside for the variable. Two, The variable name is linked to that location in memory. And three, the value of the variable is placed into the memory that was set aside. By using the & operator in front of a variable name we can retrieve the memory address-of that variable. It is best to read this operator as address-of and we will show why below. Take the following code which shows some common notations for the value-at-address (*) and adress-of (&) operators. // declare an variable ptr which holds the value-at-address of an int type int *ptr; // declare assign an int the literal value of 1 int val = 1; // assign to ptr the address-of the val variable ptr = &val; 1 P a g e

2 // dereference and get the value-at-address stored in ptr int deref = *ptr; printf("%d\n", deref); Answer: 1 int *p1,*p2,a=1,b=2; p1=&a; p2=&b; printf("a=%d\n",a); printf("b=%d\n",b); printf("*p1=%d\n",*p1); printf("*p2=%d\n\n",*p2); printf("&a=%d\n",&a); printf("&b=%d\n",&b); printf("p1=%d\n",p1); printf("p2=%d\n\n",p2); Output: a=1 b=2 *p1=1 *p2=2 &a= &b= p1= p2= &p1= &p2= printf("&p1=%d\n",&p1); printf("&p2=%d\n",&p2); int x = 1, y = 2; int *ip; ip = &x; y = *ip; *ip = 3; printf("x=%d\ny=%d\n*ip=%d",x,y,*ip); Answer: x=3 y=1 *p=3 int x=1,*p; p=&x; *p=*p+10; printf("x=%d *p=%d\n",x,*p); Answer: x=11 *p=11 int a=3,b,*pa,*pb; pa=&a; 2 P a g e

3 b=*pa; pb=&b; printf("a=%d\nb=%d\n*pa=%d\n*pb=%d\n",a,b,*pa,*pb); Answer: a=3 b=3 *pa=3 *pb=3 int a,b,c=3,*p; p=&c; a=2*(c+*p); b=*p+4; printf("a=%d b=%d\n",a,b); Answer: a=12 b=7 int a=1,b=2,*p; printf("a=%d b=%d\n",a,b); p=&a; *p=6; printf("a=%d b=%d\n",a,b); p=&b; *p=0; printf("a=%d b=%d\n",a,b); Answer: a=1 b=2 a=6 b=2 a=6 b=0 *p+=1; ++*p; all of them increments the value of the address in p by 1 *p++; *(p++); is indicating the value of the NEXT address which p has 3 P a g e

4 Pointers and Arrays Arrays in C are contiguous blocks of memory that hold multiple objects of a specified type. Contrast that with a pointer that holds a single memory location. Arrays and pointers are not the same thing and are not interchangeable. That being said an array variable points to the memory address of the first element of the array. An array variable is constant. You can t assign a pointer to an array variable, even if the pointer variable actually points to the same or a different array. You also cannot assign one array variable to another. You can assign an array variable to a pointer though and that is where things get confusing. When assigning the array to the pointer we are actually assigning the address of the first element in the array to the pointer. int myarray[4] = 1,2,3,0; int *ptr = myarray; printf("*ptr=%d\n", *ptr); Answer: *ptr=1 cannot do this, array variables are constant myarray = ptr myarray = &myarray2[0] On line 1 we initialize the array of ints. On line two we intiailize the int pointer and assign the array variable to it. Since the array variable actually is the memory address of the first element in the array, we have assigned the memory address of the first element in the array to the pointer. This is the same as doing int *ptr = &myarray[0], explicitly stating the address-of the first element in the array. Notice the pointer has to be the same type as the elements of the array, unless the pointer is a void pointer. Array Notation vs Pointer Notation When we say that arrays are treated like pointers in C, we mean the following: o The array variable holds the address of the first element in the array. It isn t a pointer but it does act like a constant pointer that cannot be changed. o Programs often interact with arrays using pointer notation instead of array notation. 4 P a g e

5 Let s look at some code: // initialize an array of ints int numbers[5] = 1,2,3,4,5,*ptr1,val1,val3,*ptr3; // standard array notation ptr1 = numbers; // ptr1 = &numbers[0]; val1 = numbers[0]; // pointer notation ptr3 = numbers + 0; val3 = *(numbers + 0); // print out the value at the pointer addresses printf("val1 = %d\n", val1); printf("val3 = %d\n", val1); Answer: val1 = 1 val3 = 1 Take a look at the following: // initialize an array of ints int numbers[5] = 1,2,3,4,5; int i ; // print out elements using array notation for (i = 0; i < 5; i++ ) int value = numbers[i]; printf("numbers[%d] = %d\n", i, value); // print out elements using pointer indexing for (i = 0; i < 5; i++ ) int value = *(numbers + i); printf("*(numbers + %d) = %d\n", i, value); // print out elements using a single pointer int *ptr = numbers,value; for (i = 0; i < 5; i++ ) value = *ptr++; printf("%d, *ptr++ = %d\n", i, value); Run that code and you get the following: 5 P a g e

6 numbers[0] = 1 numbers[1] = 2 numbers[2] = 3 numbers[3] = 4 numbers[4] = 5 *(numbers + 0) = 1 *(numbers + 1) = 2 *(numbers + 2) = 3 *(numbers + 3) = 4 *(numbers + 4) = 5 0, *ptr++ = 1 1, *ptr++ = 2 2, *ptr++ = 3 3, *ptr++ = 4 4, *ptr++ = 5 As you can see all produce the same output. Array notation is pointer arithmetic. The C standard defines that numbers[0] is just syntactic sugar for *(numbers + 0). Anytime you write array notation such as numbers[2] the compiler switches that to *(numbers + 2), where numbers is the address of the first element in the array and + 2 increments the address through pointer. int a[]=2,4,3,1,6,7,i,*p; p=a; 6 P a g e for(i=0;i<6;i++) printf("%4d",a[i]); //or printf("%4d",p[i]); printf("\n\n"); p=p+2; *p=*a+3; for(i=0;i<6;i++) printf("%4d",*(a+i)); printf("\n\n"); *(p+2)=*(a+1) * 2; for(i=0;i<6;i++) printf("%4d",*(a+i)); printf("\n\n"); Answer:

7 Do you actually know what *p++ does in C? int myarray[4]= 1,2,3,0,*p; p = myarray; int out = 0; while (out = *p++) printf("%d ", out); Answer: The above example prints out Code like *p++ is a common sight in C so it is important to know what it does. The int pointer p starts out pointing to the first address of myarray, &myarray[0]. On each pass through the loop the p pointer address is incremented, moves up one index in the array, but the previous p unincremented address (index) is dereferenced and assigned to the out variable. This happens until it hits the fourth element in the array, 0 at which point the while loop stops. But what does *p++ do? And how does it move from one element in the array to the next. In terms of operator precedence the postfix operator (++) binds tighter than the dereference operator (*). If we were reading this wrong we might think that we are incrementing the value pointed to by our p int pointer. But what is actually happening is four separate operations and a clash between operator precedence and order of operations. A fully expanded version of *p++ in code might look like this. The p pointer is assigned to x, then p is incremented. But x is still pointing at the original unincremented p address. int myarray[4]= 1,2,3,0,*p,*x; p = myarray; x = p; p = p + 1; printf("*p = %d, *x = %d\n", *p, *x); Answer: *p = 2, *x = 1 7 P a g e

8 Passing Primitives to Functions Let s look at the classic example of a swap function for passing primitives to functions. void swap(int a, int b) int tmp = a; a = b; b = tmp; int a = 1; int b = 2; printf("before swap a = %d\n", a); printf("before swap b = %d\n", b); swap(a, b); printf("after swap a = %d\n", a); printf("after swap b = %d\n", b); Run that and the output looks like this: before swap a = 1 before swap b = 2 after swap a = 1 after swap b = 2 The same values are printed before the swap function is called and after it is called. The swap function had no effect on our local a and b variables. Why? In pass by value, copies of the values of the are passed to the swap function. It is the copies that are swapped inside the function not the original variables. Now lets look at a slightly different function that uses pointers. void swap(int *a, int *b) int tmp = *a; *a = *b; *b = tmp; int main() int a = 1; int b = 2; printf("before swap a = %d\n", a); printf("before swap b = %d\n", b); swap(&a, &b); printf("after swap a = %d\n", a); 8 P a g e

9 printf("after swap b = %d\n", b); Run that and the output looks like this: before swap a = 1 before swap b = 2 after swap a = 2 after swap b = 1 In this example we use the addresses of the a and b variables as input to the swap function. The output shows that the original a and b values have been successfully swapped. Even though we are using pointers, this is still pass-by-value. Copies of the pointers to the a and b variables are being passed into the function. The function itself changes the values at those addresses but it is still being passed a copy of the pointer into the function, which is pass-byvalue. Passing Arrays to Functions When an array is passed to a function, a pointer to the address of first element of the array is copied into the function. Passing an array will not copy all of the bytes of the array into the function. Only the pointer is copied. void swap(int *nums) int tmp = *nums; int *next = nums + 1; *nums = *next; *next = tmp; int main() int nums[3] = 1,2; printf("before swap nums[0] = %d\n", nums[0]); printf("before swap nums[1] = %d\n", nums[1]); swap(nums); printf("after swap nums[0] = %d\n", nums[0]); printf("after swap nums[1] = %d\n", nums[1]); The output of this is: before swap nums[0] = 1 before swap nums[1] = 2 after swap nums[0] = 2 after swap nums[1] = 1 9 P a g e

10 Here we initialize an array of two int, print out the values of the indices, pass the array into the swap function, and then we reprint the values of the indices. What is being passed into the swap function is a copy of the array variable, meaning a copy of the address of the first element in the array. Using that address the swap function exchanges the values of the first and second index of the array. This is still pass-by-value as the address is what is copied into the swap function. While there is technically a way to copy the bytes of an array as a parameter to a function, it involves initializing an array inside of a struct and then passing the struct to a function and is in my opinion a little convoluted. And even in doing that, it is still technically pass-by-value. EXERCISES: CALL BY VALUE void func(int p) p=p+2; CALL BY REFERENCE void func(int *p) *p=*p+2; int x=5; printf("before x=%d\n",x); func(x); printf("after x=%d\n",x); int x=5; printf("before x=%d\n",x); func(&x); printf("after x=%d\n",x); void func(int *p) for(int i=0;i<5;i++) *(p+i)=*(p+i)*2; 10 P a g e

11 int x[]=5,6,7,8,9; printf("before \n"); for(int i=0;i<5;i++) printf("%4d", *(x+i)); func(x); printf("\nafter \n"); for(int i=0;i<5;i++) printf("%4d", *(x+i)); What does the following program print? void test(int *px, int *py, int pz) *px+=5; printf("%3d + %3d + %3d = %3d\n",*px,*py,pz, *px+*py+pz); *py+=(*px)++; printf("%3d + %3d + %3d = %3d\n",*px,*py,pz, *px+*py+pz); pz=((*py)+=2)*3; printf("%3d + %3d + %3d = %3d\n",*px,*py,pz, *px+*py+pz); int x=-3,y=6,z=2; printf("%3s%6s%6s%9s\n","x","y","z","x+y+z"); printf(" \n"); printf("%3d + %3d + %3d = %3d\n",x,y,z,x+y+z); test(&x,&y,z); printf("%3d + %3d + %3d = %3d\n",x,y,z,x+y+z); getch(); 11 P a g e

12 int u1,u2,i; int list[5]=10,15,20,25,30; int *ip; ip=list+2; printf("the Adress of ip : %d \t ",ip); printf("value of ip : %d \n ",*ip); for (int i=0;i<5;i++) printf("list [%d]:%d \t ",i,list[i]); ip=ip-1; printf("\n\nthe Adress of ip : %d \t ",ip); printf("value of ip : %d \n ",*ip); *(ip+2)=*ip; printf("\n\nthe Adress of ip : %d \t ",ip); printf("value of ip : %d \n ",*ip); for (i=0;i<5;i++) printf("list [%d] :%d \t ",i,list[i]); *(list+4)=*(ip-1)+2; printf("\n \n The Adress of ip : %d \t ",ip); printf("value of ip : %d \n ",*ip); for (i=0;i<5;i++) printf("list [%d] :%d \t ",i,list[i]); 12 P a g e