Let's fully draw it out:

int anArray[] = {5,16,33,99};  // 4 values in consecutive addresses

//            ----
// anArray ->   5
//            ----
//             16
//            ----
//             33
//            ----
//             99
//            ----

int * p = anArray; // A new variable, whose contents points to the address of anArray

//            ---------
// anArray ->   5       <-+
//            ---------   |
//             16         |
//            ---------   |
//             33         |
//            ---------   |
//             99         |
//            ---------   |
//       p ->  anArray   -+
//            ---------

printf("*p = %d\n", *p);  // prints 5
p++;                      // increment pointer p to the next element.

//            -----------
// anArray ->   5      
//            -----------
//             16         <-+
//            -----------   |
//             33           |
//            -----------   |
//             99           |
//            -----------   |
//       p ->  anArray+1   -+
//            ---------

printf("Now *p = %d\n", *p); // prints 16
int * q = &anArray[3];       // new pointer variable, points to 4th element of anArray (0-based)

//            -----------
// anArray ->   5      
//            -----------
//             16         <-+
//            -----------   |
//             33           |
//            -----------   |
//             99           | <-+
//            -----------   |   |
//       p ->  anArray+1   -+   |
//            -----------       |
//       q ->  anArray+3   -----+
//            -----------

int ** x = &q;  // new pointer variable, points to address of q pointer variable

//            -----------
// anArray ->   5      
//            -----------
//             16         <-+
//            -----------   |
//             33           |
//            -----------   |
//             99           | <-+
//            -----------   |   |
//       p ->  anArray+1   -+   |
//            -----------       |
//       q ->  anArray+3   -----+ <-+
//            -----------           |
//       x ->  q           ---------+
//            -----------

**x = 12;  // get address in x (q), then address in q (anArray+3) and write 12 to it

//            -----------
// anArray ->   5      
//            -----------
//             16         <-+
//            -----------   |
//             33           |
//            -----------   |
//             12           | <-+
//            -----------   |   |
//       p ->  anArray+1   -+   |
//            -----------       |
//       q ->  anArray+3   -----+ <-+
//            -----------           |
//       x ->  q           ---------+
//            -----------

*x = p;  // get address in x (q) and write p value to it (anArray+1)

//            -----------
// anArray ->   5      
//            -----------
//             16         <-+ <-+
//            -----------   |   |
//             33           |   |
//            -----------   |   |
//             12           |   |
//            -----------   |   |
//       p ->  anArray+1   -+   |
//            -----------       |
//       q ->  anArray+1   -----+ <-+
//            -----------           |
//       x ->  q           ---------+
//            -----------

**x = 42;  // get address in x (q), then address in q (anArray+1) and write a 42 to it

//            -----------
// anArray ->   5
//            -----------
//             42         <-+ <-+
//            -----------   |   |
//             33           |   |
//            -----------   |   |
//             12           |   |
//            -----------   |   |
//       p ->  anArray+1   -+   |
//            -----------       |
//       q ->  anArray+1   -----+ <-+
//            -----------           |
//       x ->  q           ---------+
//            -----------

q[1] = 9;  // get address in q (anArray+1) add one element (anArray+2), and assign 9

//            -----------
// anArray ->   5      
//            -----------
//             42         <-+ <-+   (q[0])
//            -----------   |   |
//              9           |   |   (q[1])
//            -----------   |   |
//             12           |   |
//            -----------   |   |
//       p ->  anArray+1   -+   |
//            -----------       |
//       q ->  anArray+1   -----+ <-+
//            -----------           |
//       x ->  q           ---------+
//            -----------

One reason is you want to change the value of the pointer passed to a function as the function argument, to do this you require pointer to a pointer.

In simple words, Use ** when you want to preserve (OR retain change in) the Memory-Allocation or Assignment even outside of a function call. (So, Pass such function with double pointer arg.)

This may not be a very good example, but will show you the basic use:

#include <stdio.h>
#include <stdlib.h>

void allocate(int **p)
{
    *p = (int *)malloc(sizeof(int));
}

int main()
{
    int *p = NULL;
    allocate(&p);
    *p = 42;
    printf("%d\n", *p);
    free(p);
}

A pointer-to-pointer simply means that you have an address of a memory location where some other pointer is stored. You dereference it twice to get to the final typed value.

int i = 123;
int* pi = &i;
int ** ppi = π
int j = **ppi;

There are a surprising number of situations in which you need to use one of these beasties.

1. As an output argument of a function call, pass a pointer to the pointer you want output or modified.
2. Accessing an array of C null-terminated strings; each string is itself a pointer. The argc argument to main looks like that.
3. 'Jagged' or N-dimensional arrays, stored as array of pointer to data. The data will usually be allocated with malloc().
4. A 'handle' for a memory block, so the owner of the block can move it without the user of the block needing to know.
5. Manipulating a structure that itself contains pointers, such as linked lists, trees and so on. It's basically impossible to insert an item into a linked list without them.

It's important to keep these conceptually separate. Although they all seem to use the same construct, in reality the underlying purpose is quite different. And I'm sure there are others I've missed.

I won't provide more code. There is an excellent example with diagrams and code here: http://www.eskimo.com/~scs/cclass/int/sx8.html.