What are the differences between pointer variable's value & address of normal variable and what are the special purpose of pointers in C?

Question

This may be a very basic question but the idea of having pointers in C seems confusing to me or may be I don't know the exact purpose. I will provide some examples to demonstrate what my concerns are:

1st point:

Definition says something like this:

A pointer is a variable containing the address of another variable.

So, if one program goes like this:

int i = 23;
printf("%d", i);
printf("%d", &i);

And, another program goes like this:

int i = 23;
int *ptr;  
ptr = &i;
printf("%d", *ptr);
printf("%d", ptr);

Both the programs above can output same thing.

If pointer also keeps the variable's address in it and at the same time we can get the variable's address using & sign, can't we do the same task pointer does by deriving the address of any variable? I mean if I don't declare it as pointer and use it as int ptr = &i; in 2nd code snippet and use it as normal variable, what would be the differences?

2nd point:

I found somewhere here that:

C does not have array variables....but this is really just working with pointers with an alternative syntax.

Is that statement correct? As I am still beginner, I can't validate any statement regarding this. But this was somewhat confusing to me. If that statement is correct either, then what is the actual workaround in this regard? Is it actually the pointers which works in back-end and just the compilers/ide are fooling us by using array (obviously for maintaining simplicity)?

Answer 1

Answering questions in reverse order:

C does not have array variables....but this is really just working with pointers with an alternative syntax.

This is incorrect, and you need to toss that bookmark in the trash. It's a common misconception that arrays and pointers are the same thing, but they are not. An array expression will be converted to a pointer expression under most circumstances, and array subscripting is accomplished through pointer arithmetic, but an array object is an actual array, not a pointer.

If pointer also keeps the variable's address in it and at the same time we can get the variable's address using & sign, can't we do the same task pointer does by deriving the address of any variable? I mean if I don't declare it as pointer and use it as int ptr = &i; in 2nd code snippet and use it as normal variable, what would be the differences?

That code doesn't illustrate why pointers exist, or why they are useful.

C actually requires us to use pointers in the following cases:

1. To write to a function's parameters;
2. To track dynamically allocated memory;

Pointers also make dynamic data structures like trees and lists easy to implement, but they aren't required for it (unless you're using dynamic memory allocation in those structures).

Writing to a function's parameters

C passes all function arguments by value; the formal parameter in the function definition is a separate object in memory from the actual parameter in the function call, so any change to the formal parameter is not reflected in the actual parameter. For example, assume the following swap function:

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

This function exchanges the values in a and b. However, when we call the function as

int x = 4, y = 5;
swap( x, y );

the values of x and y won't be updated, because they are different objects than a and b. If we want to update x and y, we have to pass pointers to them:

swap( &x, &y );

and update the function definition as follows:

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

Instead of swapping the contents of a and b, we swap the contents of the objects that a and b point to. This crops up all the time - think about the scanf function, and how you have to use the & operator on scalar arguments.

Tracking dynamically allocated memory

The dynamic memory allocation functions malloc, calloc, and realloc all return pointers to dynamic memory buffers; there's no variable associated with that memory as such.

char *buffer = malloc( sizeof *buffer * some_length );

A pointer is the only way to track that memory.