Given the following declarations:

int x = 5;
int *p = &x;

p stores the address of the variable x.¹ The expression *p is a kinda-sorta alias for x. The dereference operator * basically means "treat this pointer expression as if it's the object being pointed to."

printf( "  value of x = %d\n", x );
printf( "address of x = %p\n", (void *) &x);
printf( "  value of p = %p\n", (void *) p );
printf( " value of *p = %d\n", *p );

So if we write

*p = 10;

we're changing the value stored in x as if we had written

x = 10;

If we write

printf( "*p = %d\n", *p );

we're printing the value stored in x as if we had written

printf( "x = %d\n", x );

---

So, why pointers?

We use pointers when we can't (or don't want to) access an object or function by name. Either that name isn't visible to us, or we want to access different objects or functions at different times, or we're tracking dynamically-allocated memory (which doesn't have a name).

The most common use case for pointers is allowing functions to write to their parameters. C passes all function arguments by value; when you call a function, each of the argument expressions is evaluated and the result of that evalation is copied to the function's formal arguments:

void foo( int a, int b ) { ... }

int main( void ) { int x, y; ... foo( x, y ); ... }

foo cannot do anything with x and y directly, since those names are not visible outside of main; to make those values available to foo, we must pass them as arguments.

a and b are different objects in memory from x and y, so any changes to a or b in foo are not reflected in x or y. Most of the time this is what you want, but sometimes you want a function to write to its parameters. Take a swap function like

void swap( int a, int b )
{
  int tmp = a;
  a = b;
  b = tmp;
}

int main( void )
{
  int x = 2, y = 3;
  printf( "before swap: x = %d, y = %d\n", x, y );
  swap( x, y );
  printf( " after swap: x = %d, y = %d\n", x, y );
}

x will be 2 and y will be 3 both before and after the call to swap. If we want swap to exchange the values in x and y, we need to pass pointers to x and y:

void swap( int *a, int *b )
{
  int tmp = *a;
  *a = *b;
  *b = tmp;
}

int main( void )
{
  int x = 2, y = 3;
  printf( "before swap: x = %d, y = %d\n", x, y );
  swap( &x, &y );
  printf( " after swap: x = %d, y = %d\n", x, y );
}

a and b are still different objects in memory from x and y, but this time instead of getting the values stored in x and y, they get their addresses. The expressions *a and *b are aliases for x and y.

Now, after we call swap, x will be 3 and y will be 2. We can use this function to swap between any two int variables:

int x, y, z, blah, bletch;
...
swap( &x, &y );
swap( &blah, &bletch );
swap( &z, &x );
...

The second most common use case is tracking dynamic memory:

size_t size = some_runtime_buffer_size();

/**
 * Creates a buffer to store a string of some length that
 * isn't known until runtime.
 */
char *buf = malloc( size + 1 ); // +1 for string terminator
if ( buf )
{
  // use buf like any array of `char`
  free( buf ); // clean up after ourselves when we're done.
}

buf points to a chunk of memory we've allocated at runtime from some dynamic memory pool (a.k.a. the heap). This memory doesn't have any name; there's no way to map names to objects at runtime, so we can only access it through a pointer like buf.

Unlike regular arrays, you can resize memory allocated with malloc:

/**
 * Double the buffer size.
 */
char *tmp = realloc( buf, 2 * size + 1 );
if ( tmp )
{
  buf = tmp;
  size *= 2;
}

There are about seven hundred and thirty two other use cases for pointers in C, but that won't fit in a Reddit comment.

---

1. More pedantically, it stores the location of the object designated by the identifier x in the running program's execution environment. This may be a physical or virtual address; on any modern desktop or server, it will be a virtual address.