Q:

When using calloc in C what is stored at the address of the pointer?

I'm having a hard time understanding this program to illustrate pointers (from http://theocacao.com/document.page/234):
Below I don't understand why:
int * currentSlot = memoryBlock

isn't using &memoryBlock.  I read the comment but don't get it.  What is memoryBlock putting in there that &memoryBlock wouldn't?  Won't both return the pointer to the set of ints created with calloc (assuming I understand what's been done that is)?  What is really in * memoryBlock after calloc?
Then here, *currentSlot = rand();, how does the dereferencing work here?  I thought the dereference would stop *currentSlot from giving the value of the memory address (the reference) to the actual value (no longer a reference but the value).
#include <stdio.h>
#include <stdlib.h> // for calloc and free
#include <time.h>   // for random seeding

main ()
{
  const int count = 10; 
  int * memoryBlock = calloc ( count, sizeof(int) );

  if ( memoryBlock == NULL )
  {
    // we can't assume the memoryBlock pointer is valid.
    // if it's NULL, something's wrong and we just exit
    return 1;
  }

  // currentSlot will hold the current "slot" in the,
  // array allowing us to move forward without losing
  // track of the beginning. Yes, C arrays are primitive
  //
  // Note we don't have to do '&memoryBlock' because
  // we don't want a pointer to a pointer. All we
  // want is a _copy_ of the same memory address

  int * currentSlot = memoryBlock;

  // seed random number so we can generate values
  srand(time(NULL));

  int i;    
  for ( i = 0; i < count; i++ )
  {
    // use the star to set the value at the slot,
    // then advance the pointer to the next slot    
    *currentSlot = rand();
    currentSlot++; 
  }

  // reset the pointer back to the beginning of the
  // memory block (slot 0)
  currentSlot = memoryBlock;

  for ( i = 0; i < count; i++ )
  {
    // use the star to get the value at this slot,
    // then advance the pointer
    printf("Value at slot %i: %i\n", i, *currentSlot);
    currentSlot++;
  }

  // we're all done with this memory block so we
  // can free it  
  free( memoryBlock );
}

Thank you for any help.

A:

Below I don't understand why:
int * currentSlot = memoryBlock

isn't using &memoryBlock.

Because both memoryBlock and currentSlot are pointers to int. &memoryBlock would be the address of a pointer to int, i.e. an int **.
What is "in" memoryBlock is a pointer to a block of memory.

Then here, *currentSlot = rand();, how does the dereferencing work here?

This is a rule of C: when a dereferencing expression like this occurs on the left-hand side of an expression, the right-hand side's value is stored in the memory location pointed to by the pointer being dereferenced.

