CSCU9Y4 Programming Language Paradigms Practical 6 Pointers and arrays The concept of arrays is related to that of pointers. In fact, arrays work very much like pointers to their first elements, and, actually, an array can always be implicitly converted to the pointer of the proper type. For example, consider these two declarations: int myarray [20]; int * mypointer; The following assignment operation would be valid: mypointer = myarray; Here, myarray is a synonym for &myarray[0]. After the assignment above, mypointer and myarray would be equivalent and would have very similar properties. The main difference being that mypointer can be assigned a different address, whereas myarray can never be assigned anything, and will always represent the same block of 20 elements of type int. Therefore, the following assignment would not be valid: myarray = mypointer; Let’s see an example that mixes arrays and pointers: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // more pointers int main () { int numbers[5]; int * p; p = numbers; *p = 10; p++; *p = 20; p = &numbers[2]; *p = 30; p = numbers + 3; *p = 40; p = numbers; *(p+4) = 50; for (int n=0; n<5; n++) printf("%d, ", numbers[n]); return 0; } The output is 10, 20, 30, 40, 50, Why? Make sure you understand what all the different assignment statements do. Pointers and arrays support the same set of operations, with the same meaning for both. The main difference being that pointers can be assigned new addresses, while arrays cannot. Essentially, this is because brackets in an array expression are a dereferencing operator known as offset operator. They dereference the variable they follow just as * does, but they also add the number between brackets to the address being dereferenced. For example: a[5] = 0; // a [offset of 5] = 0 *(a+5) = 0; // pointed by (a+5) = 0 These two expressions are equivalent and valid, not only if a is a pointer, but also if a is an array. Remember that if an array, its name can be used just like a pointer to its first element. Pointers as function parameters (1) Recall that if we have call by value then we can implement call by reference by using pointers. The example from the lectures is a swap function. It's repeated here: void swap(int* first, int* second) { int temp; temp = *first; *first = *second; *second = temp; } int main () { int dee, dum; dee = 42; dum = 56; swap(&dee,&dum); printf("Dee is %d\n",dee); printf("Dum is %d\n",dum); return 0; } Run this and convince yourself that you understand how it works. Compare this with a version without pointers: void swap(int first, int second) { int temp; temp = first; first = second; second = temp; } int main () { int dee, dum; dee = 42; dum = 56; swap(dee,dum); printf("Dee is %d\n",dee); printf("Dum is %d\n",dum); return 0; } This version fails to actually swap the values of dee and dum. Pointers and const Pointers can be used to access a variable by its address, and this access may include modifying the value pointed to. But it is also possible to declare pointers that can access the pointed value to read it, but not to modify it. For this, it is enough with qualifying the type pointed by the pointer as const. For example: 1 2 3 4 5 int x; int y = 10; const int * p = &y; x = *p; // ok: reading p *p = x; // error: modifying p, which is const-qualified Here p points to a variable, but points to it in a const-qualified manner, meaning that it can read the value pointed, but it cannot modify it. Note also, that the expression &y is of type int*, but this is assigned to a pointer of type const int*. This is allowed: a pointer to non-const can be implicitly converted to a pointer to const. But not the other way around! As a safety feature, pointers to const are not implicitly convertible to pointers to non-const. Pointers as function parameters (2) One of the use cases of pointers to const elements is as function parameters: a function that takes a pointer to non-const as parameter can modify the value passed as argument, while a function that takes a pointer to const as parameter cannot. 1 2 3 4 5 6 7 8 9 10 11 // pointers as arguments: void increment_all (int* start, int* stop) { int * current = start; while (current != stop) { ++(*current); // increment value pointed ++current; // increment pointer } } 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 void print_all (const int* start, const int* stop) { const int * current = start; while (current != stop) { printf("%d\n",*current); ++current; // increment pointer } } int main () { int numbers[] = {10,20,30}; increment_all (numbers,numbers+3); print_all (numbers,numbers+3); return 0; } The output is 11 21 31 Note that print_all uses pointers that point to constant elements. These pointers point to constant content they cannot modify, but they are not constant themselves: i.e., the pointers can still be incremented or assigned different addresses, although they cannot modify the content they point to. And this is where a second dimension to constness is added to pointers: Pointers can also be themselves const. This is specified by appending const to the pointed type (after the asterisk): 1 2 3 4 5 int x; int * p1 = &x; // non-const pointer to non-const int const int * p2 = &x; // non-const pointer to const int int * const p3 = &x; // const pointer to non-const int const int * const p4 = &x; // const pointer to const int The syntax with const and pointers is definitely tricky, and recognizing the cases that best suit each use tends to require some experience. In any case, it is important to get constness with pointers (and references) right sooner rather than later, but you should not worry too much about grasping everything if this is the first time you are exposed to the mix of const and pointers. To add a little bit more confusion to the syntax of const with pointers, the const qualifier can either precede or follow the pointed type, with the exact same meaning: 1const int * p2a = &x; // non-const pointer to const int 2 int const * p2b = &x; // also non-const pointer to const int As with the spaces surrounding the asterisk, the order of const in this case is simply a matter of intensely-debated style. Checkpoint Now attempt these questions and demonstrate to a tutor that you have completed them: Question 1 Write a program that initialises an array of double and then copies the contents of the array into two other arrays. Here is an example showing how the functions should be called, given the following declarations: double source[4] = {1,2.3,4.5,6.7}; double destination1[4]; double destination2[4]; copy_array(source, destination, 4); copy_ptr(source, destination, 4); Hints: Declare all arrays in the main program. To make the first copy, make a function copy_array(), which uses the array notation (the square brackets []) to access the elements of the array. To make the second copy, write a function copy_ptr(), which uses the pointer notation and pointer incrementing to access the elements of the arrays. Have each function take as function arguments the name of the target array and the number of elements to be copied. Test the two copy functions in the main program. Question 2 Write a function dif(), which uses the pointer notation in the function body and returns the difference between the largest and smallest elements in an array of double. Test the function in the main program. Question 3 Write a function add(), which uses the pointer notation in the function body and adds the elements of two one-dimensional arrays of same size. The results should be stored in a third array. The function should take as arguments of the names of th e three arrays and the array dimension. Test the function in the main program. Optional extras: Write a program that initialises a two-dimensional array of double and uses the second copy functions (i.e. the one using pointer in Question 1) to copy it to a second two-dimensional array. Use the one-dimensional copy function to copy the sub-arrays of the two-dimensional array, one-by-one. Hint: Remember how the two-dimensional arrays are stored in the memory! Pointers and string literals As pointed earlier, string literals are arrays containing null-terminated character sequences. In earlier sections, string literals have been used to be directly inserted into cout, to initialize strings and to initialize arrays of characters. But they can also be accessed directly. String literals are arrays of the proper array type to contain all its characters plus the terminating null-character, with each of the elements being of type const char (as literals, they can never be modified). For example: const char * foo = "hello"; This declares an array with the literal representation for "hello", and then a pointer to its first element is assigned to foo. If we imagine that "hello" is stored at the memory locations that start at address 1702, we can represent the previous declaration as: Note that here foo is a pointer and contains the value 1702, and not 'h', nor "hello", although 1702 indeed is the address of both of these. The pointer foo points to a sequence of characters. And because pointers and arrays behave essentially in the same way in expressions, foo can be used to access the characters in the same way arrays of null-terminated character sequences are. For example: 1 2 *(foo+4) foo[4] Both expressions have a value of 'o' (the fifth element of the array). References: material taken from http://www.cplusplus.com/doc/tutorial/pointers/
