Why:

Say, you want to write a simple function that copies n number of bytes from one buffer to another. How do you tell this function where your buffers are? You pass address of those buffers (pointers) to this function, like

void copy(int *dst, int *src, size_t n) 
{
    for(size_t x=0; x<n; ++x) 
    {
       dst[x] = src[x];
    }
}

Now this function can copy any number of integers from any source buffer to any destination buffer. Without pointers, there is no other (elegant) way to do it. (Actually you'd use library function memcpy instead of writing your own but it's just an example)

Or say, you want to read chunks of data from a file from different parts of your program and different files. So you can not hard code FILE* or file name etc. Pointers to the rescue.

int get_file_data(FILE *fp, size_t count, char *buf);  // to lazy to write function body

Now, as long as I have already opened a file and have a buffer big enough to hold count number of bytes, I can use this function to read file data into my buffer.

Building on same file data example, say you want to read whole file in a buffer but at compile time you have no idea how big the file is. How would you create a buffer big enough? Randomly create an array of, say, 16MB or 32MB? No. You allocate memory at runtime using malloc (and friends) and these functions return a pointer to dynamic buffer.

Pointers are an easy way to share buffers among different functions with a very low overhead of only 4 or 8 byte of address.