I have a question regarding pointer initialization in C.
I understand that *ptr will give the value of that pointer is pointing to.
ptr will give you the address.
Now I got following syntax:
int *ptr = (int *) malloc(sizeof(*ptr));
Why is *ptr being initialized with an address of the Heap and not a value? malloc() returns an address right?
Shouldn't it be:
int *ptr;
ptr = malloc(...);
With *ptr, * is acting as the dereferencing operator.
With int *ptr, * is acting as part of the type declaration for ptr.
So the two things are entirely different, even though * is used. (Multiplication and comment blocks are further uses of * in C).
In that line, int * is the type.
int *ptr = (int *) malloc(sizeof(*ptr));
Is just this compressed into one line:
int *ptr;
ptr = (int *) malloc(sizeof(*ptr));
int* ptr rather than int *ptr. This isn't a universal view, though.
int* ptr, variable;
int *ptr = malloc(sizeof(*ptr)) is wrong?Actually , this:
int *ptr = (int *) malloc(sizeof(*ptr));
Is just short syntax for this:
int *ptr;
ptr = malloc(...);
The * is used for defining a type pointer and not to dereference the pointer .
Both snippets above do the same thing.
In the first case, the * before ptr is not the derefernece operator but is part of the definition of the type. So you actually are assigning a value to (initializing, actually) ptr, not *ptr.
The difference between
int *ptr = (int *) malloc(sizeof(*ptr));
and
int *ptr;
ptr = malloc(...);
is basically the same as the difference between
int i = 5;
and
int i;
i = 5;
The first variant defines and initializes a variable in one go. The second variant defines the variable but leave it uninitialized, and then assign a value to it.
int *(pointer toint) fromptr = (int *) malloc(sizeof(*ptr));and you have your answer.*is context-sensitive. It means "pointer to" in one context, "pointer dereference" in another and "multiplication" as well.void-pointers in C.malloc(and such a cast could actually lead to bugs).int *ptr=> ptr is a variable that deferenced with*gives anint.