Pointers

• Pointer variables
  • Nothing useful yet, just the idea
  • Pointers to primitive types
    • The definition int *pi1; says pi1 will hold the address of an integer, or *pi1 is an int.
    • The unary operator & gives the address of an object.
    • The unary operator * implements indirection on its argument.
    • Assigning pointers to pointers
    • Pointers can be manipulated like other variables, e.g. assignment and increment (what does this mean).
    • PrimitivePointers.c - program demonstrating pointers to primitive types
  • The NULL pointer
    • NULL is defined in stdio.h as 0.
    • Pointers and ints are not interchangable (despite a cavalier attitute of classic C programmers).
    • The only integer that may be assigned to or compared with a pointer is 0. Using NULL makes this explicit.
    • C guarantees no pointer to data will contain 0, so returning NULL for an error is safe.
    • NullPointer.c - program demonstrating a null pointer
  • Array of pointers
    • ElementPoints.c - Program demonstrating use of an array of pointers

• Pointers as parameters
  • Pass by value (= pass the referred object by reference)
  • PassByValue.c - Program demonstrating passing pointers by value
  • Pointers to pointers pass pointers by reference
  • PassByReference.c - Program that passes a pointer to a pointer.

• BEWARE following pointers ... you'd better know where they go
  • If you follow a pointer to a place you don't own, you'll get a seg fault.
  • If you follow a pointer to a place that doesn't exist, you'll get a bus error.
  • Virgin Airlines

• Pointers and arrays.
  • Pointers and arrays are closely linked in C. Anything that can be done with array subscripting can be done with pointers.
  • An array name provides the address of the first element of the array. e.g. int A[10]; Then A == &A[0] and *A == A[0].
  • An array name is a constant address and cannot be assigned a new value, but a pointer to an array element can.
  • Given a pointer PA into an array A (the array name counts as a pointer to the first element), then the pointer can be indexed like an array.
  • Given a pointer PA into an array A (the array name counts as a pointer to the first element), then adding or subtracting an integer gives a pointer offset that far along the array.
  • Given two pointers into an array, subtracting them gives the number of elements from one to the other.
  • Incrementing or decrementing a pointer (which is pointing into an array) moves the pointer along the array
  • ArrayPointer.c - Using pointers into an array
  • Function arguments
    • It is possible to pass part of an array to a function by passing the address of the element at the start of the required part. e.g. strlen(&s1[3]).
    • The receiving function may view the passed address as an array (subscripted from 0 again) or as a pointer to an element.
    • ArrayRestart.c - Offsets an array in a function
  • Multi-dimensional array accesses are also converted to pointer access.
    • Given the definition int a[5][8], a[3][5] is converted to *(*(a+3)+5) in the steps a[3] => *(a+3), a[3][5] => *(a+3)[5] => *(*(a+3)+5).
    • a - a pointer to the 1st of 5 arrays of 8 elements.
    • a+3 - a pointer to the 4th 8 element array.
    • *(a+3) - a pointer to the 1st element of the 4th 8 element array (because the 4th 8 element array is an array!!. If it were a number it would be the number).
    • *(a+3)+5) - a pointer to the 6th element of the 4th 8 element array.
    • *(*(a+3)+5) - the 6th element of the 4th 8 element array.
  • Pointer arithmetic on addresses in different arrays is dangerous as order of memory allocation is not consistent between compilers. No pointer arithmetic other than that described here should be used.

• Character pointers and functions.
  • String constants and arrays of char are implemented the same.
  • When a character string (or any array) is passed to a function, a pointer to the start of the string is actually passed. The end of a string is marked with a \0.
  • The definitions

    char message[] = "Hello world";
    char *message = "Hello world";
    char *message;
    message="Hello world";
              

    are different. The first defines an array, the second and third a pointer to a string, somewhere where the compiler puts it. Take care that you own the memory that you use
  • StringPointers.c - Dangerous games with strings
  • C does not provide string manipulation directly, but there are plenty of library routines, declared in string.h and stdlib.h.

• Arrays of pointers and arrays of arrays
  • This works neatly because array names are pointers, so a pointer can be assigned an array, e.g. sorting arrays of strings into order can be done by swapping pointers to the strings, rather than swapping the strings themselves.
  • Useful for ragged right edge arrays.
  • StringsSort.c - Sorting strings by pointers
    • Name is an array of pointers to character.
    • Each of these characters is the first in an initialised array. (Pointer to a character is also a character array).
    • The characters of the ith string are stored somewhere and a pointer to them is stored in Name[i].
    • The size of name is given implicitly by the number of strings in the initialisation.
  • Pointers vs Multi-dimensional arrays
    • int A[10][10], *B[10]; defines A to be a 2D array of 100 ints and B to be an array of 10 pointers to int.
    • A[4][6] and B[4][6] are both syntactically legal. A[4][6] is the 7th element in the 5th array. B[4][6] is the memory location 6 ints beyond the address given in the 5th array element, equivalent to *(B[4] + 6). If B[4] points to an array of ints of length >=7 the two are equivalent.
    • The setting up of B to point to arrays is the programmer's responsibility. The setting up of A to the 10 x 10 format is the compiler's responsibility.

• Pointers to functions.
  • Pointers to functions can be passed to functions.
  • SortByFunction.c - Program demonstrating passing functions as parameters.
  • As CompareGreater and CompareLess are defined (declared) before main, they are known to be functions of type int, and the compiler will pass their addresses to sort. (For functions addresses are passed, like arrays.)
  • The declaration int (*CompareFunction)(int,int) says CompareFunction is a pointer to a function of type int and takes two int arguments.
    • The () are necessary round (*CompareFunction) as (int,int) takes precedence over *.
    • int *F(int,int) declares a function that returns a pointer to an int.
    • int *(*F)(int,int) declares a pointer to a function that returns a pointer to an int.
  • The call (*CompareFunction)(Data[Index],Data[Index+1]) is consistent with the declaration.
    • CompareFunction is a pointer to a function
    • *CompareFunction is a function.
    • The () are needed to provide the correct associations.
  • These pointer declarations can get confusing, due to the use of () for indicating functions, and indicating precedence.
    • In precedence () = [] > *
    • () and [] have left to right associativity, * has right to left associativity.
    • Try these examples, using precedence and associativity to justify the types :
      • char **PPC; - PPC is pointer to a pointer to char.
      • int (*Table)[13]; - Table is a pointer to an array of 13 ints.
      • int *Table[13]; - Table is an array of 13 pointers to int.
      • void *F(void); - F is a function that returns a pointer to void, and takes no arguments.
      • void (*F)(char); - F is a pointer to a function that returns a void, and takes a char argument.
      • char (*(*F(void))[])(int,int); - F is a function of no arguments returning a pointer to an array of pointers to functions that return char and have two int arguments.
      • char (*(*A[])(float))[5]; - A is an array of pointers to functions that return pointers to arrays of 5 char, and take one float argument.
  • The qsort standard library function is very useful function that is designed to sort an array by a key value of any type into ascending order, as long as the elements of the array are of fixed type.
    • qsort is prototyped in stdlib.h:

      void qsort(void *base, size_t num_elements, size_t element_size,
         int (*compare)(void const *, void  const *));
                     

    • The argument base points to the array to be sorted, num_elements indicates how long the array is, element_size is the size in bytes of each array element and the final argument compare is a pointer to a function.
    • qsort calls the compare function which is user defined to compare the data when sorting. qsort thus maintains it's data type independence by giving the comparison responsibility to the user.
    • The compare function must return integer values according to the comparison result:
      • less than zero : if first value is less than the second value
      • zero : if first value is equal to the second value
      • greater than zero : if first value is greater than the second value
    • Some quite complicated data structures can be sorted in this manner.

• Command-line arguments.
  • The main routine of a C program has two optional arguments, the first being the number of fields separated by blanks on the command line (including run name), and the second an array of pointers to these character strings.
  • The 0th pointer points to the run name.
  • CommandLine.c - Program looking at its command line

Exercises

• Write a code segment that declares an array of 10 pointers to int, initializes all of them to point at the int variable anInt, and finally prints out the contents of anInt using the 5th array element.
• What is the output from the following code?

  char Name[12];
  char *Offset;
  
  strcpy(Name,"Sutcliffe");
  Offset = &Name[4];
  printf("%s\n",Offset);
       

• Write a code segment that declares a pointer to a float, and then makes the pointer be the "name" of a newly created array of 10 floats.
• Write a pointer version of the void squeeze(char *s1,char *s2) function, that deletes each character in s1 that matches a character in s2.
• Write an improved dispose_heap_frame function char *dispose_heap_frame(char *frame,int size) that checks that frame does extend to the top of the heap, returning frame if successful, NULL if an error occurs.
• Improve the sorting example given by writing a choose_direction function that returns a pointer to one of compare_greater and compare_less, depending on whether the user inputs an A or not. The if-then-else construct in the main function can then be replaced by : sort(data,number_of_numbers,choose_direction());.
• Write a C program to read through an array of any type using pointers. Write a C program to scan through this array to find a particular value.
• An insertion sort is performed by adding values to an array one by one. The first value is simply stored at the beginning of the array. Each subsequent value is added by finding its ordered position in the array, moving data as needed to accommodate the value and inserting the value in this position. Write a function called insort that performs this task and behaves in the same manner as qsort, i.e it can sort an array by a key value of any type and it has similar prototyping.

Exam Style Questions

• Any of the short exercises.
• What is the difference between *i1 in the following two lines?

  int *i1;
  
  *i1 = 27; 

• What does the & operator return when applied to a variable?
• What is the output from the following code?

  int data[] = {8,7,6,5,4,3,2};
  int *bean;
  
  bean = &data[3];
  printf("%d %d\n",bean[data[6]],&data[5]-bean); 

• Given the multidimensional array float values[4][3];, what is the equivalent pointer expression for values[2][2]?
• What errors might the following code produce?

  char string[128];
  char *name;
  
  strcpy(string,name);
  strcpy(name,"old stuff"); 

• Give an example showing how an array of pointers can be used to create a two dimensional array in which the rows are of differing lenths.
• Give typedefs to define a data type for an array of three pointers to functions, where each function takes two int arguments and returns a float. (OK, that's hard, I admit).
• Write a program that takes integers as command line arguments, sums them, and returns the sum back to the operating system.