Why is the * used to declare pointers?

It remove indirection, but doesn't remove any when you declare a pointer like int *a = &b, shouldn't it remove the indirection of &b?

CodePudding user response：

Any time you have a pointer declaration with initialization like this:

type *x = expr;

it is equivalent to the separate initialization followed by assignment:

type *x;
x = expr;

It is not equivalent to

type *x;
*x = expr;      /* WRONG */

CodePudding user response：

It's part of the declaration, so it's not a dereference operator at all. Yet it still means the same thing.

int *a

can be read as

The value pointed by a is an int.

just like

printf("%d\n", *a);

can be read as

Print the value pointed by a.

See this answer to Correct way of declaring pointer variables in C/C for a bit on background on this.

CodePudding user response：

Many symbols in C and C are overloaded. That is, their meanings depend on the context where they are used. For example, the symbol & can denote the address-of operator and the binary bitwise AND operator.

The symbol * used in a declaration denotes a pointer:

int b = 10;
int *a = &b,

but used in expressions, when applied to a variable of a pointer type, denotes the dereference operator, for example:

printf( "%d\n", *a );

It also can denote the multiplication operator, for example you can write:

printf( "%d\n", b ** a );

that is the same as

printf( "%d\n", b * *a );

Similarly, the pair of square braces can be used in a declaration of an array, like:

int a[10];

and as the subscript operator:

a[5] = 5;

CodePudding user response：

Back when C was invented, a somewhat interesting choice was made. Variables would be declared in a kind of echo of how they would be used.

So

int a;

means "you can get an int out of a. Then,

int *a;

means you can get an int out of *a.

And,

int a[3];

means you can get an int out of a[index]; here, the size is put in where the index would be.

This can be chained to complex cases

int *a[3];

vs

int (*a)[3];

now if you don't know how C parsing works, this is opaque; but at least you only have to learn it once!

This is why some people think int* a is bad form, because the * is really attached to a not the int.

Initialization of the named variable is a different thing.

(some declaration) = (some expression)

the symbols in the declaration never act as expressions. They are the same symbols, just different meaning.