Pointers are the only mechanism in C to share memory between different two functions, and it's common to want/need to do that even if it doesn't seem obvious at first.

consider this code:

void f(int x) {
  x = 6;
}

int main(int argc, char *arg[]) {
  int x = 2;
  f(x);
  printf("%d\n", x);
  return 0;
}

This will print 2 - the x that you passed into the function is changed inside the function, but that's only visible inside the function.

Often that's exactly what you want (in fact, there's a school of thought that all programs should behave this way and only this way - that's called "functional programming" but unfortunately C isn't expressive enough to support it). Some times it isn't, and so instead you want to share the memory:

void f(int *x) {
  *x = 6;
}

int main(int argc, char *argv[]) {
  int x = 2;
  f(&x);
  printf("%d\n", x);
  return 0;
}

This prints "6" - the change inside the function is visible outside the function.

This is a simplistic example (it'd be rare to want a function to change the value of an integer in its calling function) but when you get into structs and things, you often need the calling function to be able to interact with its caller this way.

Pointer syntax is kind of intimidating, but remember that your computer's memory is just one big giant array. Each variable that you can interact with has an "address" which is an entry in that giant array. "&" means "get the index of this memory location" and "*" means "update the memory at this location". The second example is maybe easier to understand using array syntax:

int mem[100];

void f(int i) {
  mem[i] = 6; // equivalent to *x = 6
}

int main(int argc, char *argv[]) {
  mem[26] = 2;  // equivalent to int x = 2;
  f(26);   // equivalent to &x
  printf("%d\n", mem[26]);
  return 0;
}

Here I'm "pretending" that memory is a global array (except I'm not really pretending because it actually is!). I chose an arbitrary location of 26 (in practice the compiler picked one for me when I declared int x = 2) and then passed this index to the function. This is what &x does: it asks the compiler to give back the arbitrary index that points to "x" in memory. The call

mem[i] = 6

"dereferences" this "pointer" just like

*x = 6

does, I'm just making it look more explicit.