Week 13 - Chapter 12
Pointers and Arrays

Review Quiz 4
-------------

Review Chapter 11 Homework
--------------------------

Pointer Arithmetic
------------------

We can use pointers to work with arrays in ways that may seem trivial, because
we can often do the same things with array indexes.  But there are some
advantages to how code looks when using pointers instead of indexes.

First, some code:

  int a[10];
  int *p, *q;

Normally, when we initialize a pointer variable, we do it by providing the
address of a scalar variable.  So we can with pointers and the members of an
array:

  p = &a[0];

This code points the p pointer to the beginning of the a array.  We can also
use a handy shorthand with arrays and pointers that I'll explain more later,
and that is to assign the pointer the name of the array itself:

  p = a;

  +--+--+--+--+--+--+--+--+--+--+
a | 0| 1| 2| 3| 4| 5| 6| 7| 8| 9|
  +--+--+--+--+--+--+--+--+--+--+
   ^
   |
   p

With pointer arithmetic, we can add to and subtract from a point to traverse
the array.  The pointer is type specific, so if we tell the pointer to add one
to itself, it moves right the exact number of bytes it needs to to point to the
next member of the array:

  p++;       (move right one cell, point to 1)
  p+=2;      (move right two cells, point to 3)

Because the value (p+2) is a pointer value, we can assign values like that to
other pointer variables:

  q = p+2;   (q points to 5)

And just as we can move right through an array, we can move left, too:

  q--;       (move left one cell, point to 4)

Once you have two pointers pointing inside the same array, you can actually do
math on the pointers, to learn something about their relation to each other in
the array:

  i = q-p;   (1 (4-3))
  i = p-q;   (-1 (3-4))

Based on this, we can tell which pointer is first in the array:

  if (p < q) {
    printf("p is pointing before q\n");
  }
  else if (q > p) {
    printf("q is pointing before p\n");
  }
  else {
    printf("p and q are pointing to the same spot\n");
  }

Using this method, we can traverse an entire array just using pointers:

  #define NUM 10

  total = 0;
  for (i=0, p = a; i<NUM; i++, p++) {   // Still using a counter
    total += *p;
  }

  for (p=a; p<&a[NUM]; p++) {           // Just using pointers
    total += *p;
  }

Note that technically, &a[NUM] does not exist - it is out of bounds of the
array, which is only 10 elements long.  But this is actually OK, despite my
admonishments not to access data beyond the bounds of an array.  In this case,
we are merely examining the address of the non-existent member, not reading or
writing it.

Parentheses with pointers
-------------------------

A quick aside now that we are doing pointer math.  Be careful of where the
symbols, like ++ and *, go.

  *p++;         (what does it do?)

The ++ has higher precedence than the *, so the ++ first moves the pointer to
the right, then accesses the data that is stored there - it changes p, but not
the data pointed to be p.  If you wanted to add one to the value pointed to by
p, need to do this:

  (*p)++;

The *p in side the () tell the program to access the value pointed to first,
then add one to it.


Pointers and Arrays
-------------------

Pointers and arrays are very tightly related.  This is best illustrated by this
statement:

  p = a;

Used above, I said this pointed p to the beginning of the array, which is true.
But it did it without the & operator ... or did it?  The truth is, the name of
an array is a pointer value.  So, "p=a" is perfectly legal - it is setting one
pointer value equal to another.

That having been said, what does this do?

  i = *(a+2);

This assigns i the value of a[2].  Of course, you could just as easily say:

  i = a[2];

But this ability can help us in other ways.  One thing to remember, though,
about using an array name as a pointer:  You cannot move where the array name
points.  It always points to the beginning of the array, so you cannot do:

  a++;
  a+=2;

These are both errors that the compiler will find.

Passing an array to a function
------------------------------

By now it should be clear that because the name of an array is a pointer, that
when we do:

  sum_array(a);

and pass he name of an array to a function, the function gets a reference to
the values, not the values themselves.  This in itself is a huge time saver,
because programs do not need to make copies of arrays. We can also, handily,
pass the array at some point other than its middle:

  int fn(int *, int *);

  int a[20];
  p - a;

  fn(a,20);           // Pass entire array to fn()
  fn(a+10,10);        // Pass only last ten members to fn()
  fn(a,10);           // Of course, you can also limit the number to process

Accessing a pointer like an array
---------------------------------

To further tie arrays and pointers together, we can also use array access
syntax to access pointer data, once the pointer points to an array.

  int a[10];
  int *p;

  p = a;
  p[4] = 4;
  *(p+5) = 5;

  a[6] = 6;
  *(a+7) = 7;

Multidimensional arrays
-----------------------

When working with multidimensional arrays, we can work with pointers in much
the same way, but we also have some things to take into consideration.

  int a[10][10];
  int *p;

To point p to the beginning of the a array now, we do:

  p = a[0];

This is because a is not a pointer to an int the way it is when it only has a
single dimension - it is a pointer to a pointer to an int.  The only way p can
point to a is to declare p with double indirection:

  int a[10][10];
  int **p;

  p = a;

This is rarely necessary, because we can process a multidimensional array in
much the same way as a single dimension.  For example, to use pointers to
initialize a two-dimension array:

  for (p=a[0]; p<a[10]; p++)
    *p = 0;

Note here we use the same "out of bounds" method that we used before - a[10]
points to the cell that immediately follows a[9][9] - we should not read or
write that data, but we can check the memory location without concern.

When we have a multidimensional array, we also have to be careful how we pass
it to functions.  A function designed to get an array won't work with a
multidimensional array without slight modification of the call.

  int total_array(int [], int);
  ...
  total_array(a,100);     // Won't work because it expects int [] (int *)
                          // and a is int[][] (int**)

To fix this, just modify how the array is passed:

  total_array(a[0],100);

A few more tips
---------------

We can subtract two pointers to find out how far apart they are - but we cannot
add them - doing so would have no useful effect.

You can subtract any pointers, but it only makes sense to do so when the two
pointers are pointing to the same array.