Thread: Unclear to pointers.

well, I have some touch question and I really need help, good explanation needed for answering them.

1)Can anyone explain exactly what do

Code:

int *p=10

&&

Code:

int *p=NULL

stand for? and isn't

Code:

NULL

considered as a value?
I actually understood pointers, since *p => resemble the value of pointer p.

2)why can't I write like

Code:

int *p;
p=10;

? isn't that equivalent to int *p=10?
and why if I write like

Code:

int *p;
p=NULL;

it will work normally??

This declares a pointer named p of type int* and initialises it to an address of value 10:

Code:

int *p = 10;

Unless you are dealing with an environment where you are supposed to initialise the pointer to an address with value 10, you should not do this.

This declares a pointer named p of type int* and initialises it to be a null pointer:

Code:

int *p = NULL;

NULL is an implementation defined null pointer constant. For example, your standard library implementation might have:

Code:

#define NULL 0

or

Code:

#define NULL ((void*)0)

or something else such that NULL is a null pointer constant.

Originally Posted by Romyo2

2)why can't I write like

Code:

int *p;
p=10;

? isn't that equivalent to int *p=10?

You should be able to do that if you are able to initialise p to 10 in the first place. If not, maybe your compiler is just trying to stop you from doing something stupid... like hard coding an assignment that assigns 10 to the pointer even though the address 10 is not guaranteed to be available for you.

Originally Posted by Romyo2

Got you, so what I've posted in comment #2 is completely correct, right?
NULL can be used either as a value or a pointer.

No. NULL is not (necessarily) a pointer. It is a null pointer constant.

Originally Posted by Romyo2

I'm with you!

then why when I write this syntax writing as :

Code:

int *p;
p=NULL;

in my compiler(Visual C++ 2010) shows the same result as

Code:

 *p=NULL

?

The first code snippet declares p, then assigns NULL to p, causing it to be a null pointer. The second code snippet dereferences p and assigns NULL to the result. This is semantically wrong since p is a pointer to int, so *p is an int, hence you should not be assigning NULL to it since NULL is a null pointer constant.

That said, my guess is that you are confusing this:

Code:

int *p = NULL;

with:

Code:

*p = NULL

I have already explained the former in post #3.

Originally Posted by Romyo2

Also it's showing an error while writing

Code:

int main()
{
	int *p=NULL;
	*p=9;
	printf("%d", *p); // it should print the number f9//
	return 0;
}

!!

Since you initialised p to be a null pointer, you cannot dereference p since a null pointer does not point to an object.

Originally Posted by Romyo2

I conclude if an pointer has been initialised to be a null pointer, its value(value of the null pointer) can't be changed because the null pointer is constant and has always the value 0/<null> , right?

No, a null pointer and a pointer that is constant are not necessarily the same. This declares p1 to be a pointer to int that is a null pointer:

Code:

int *p1 = NULL;

In the above, you can modify p1 by say, assigning another pointer to it, but you cannot access, much less modify, what p1 points to because p1 does not point to anything.

This declares p2 to be a pointer to int that is constant:

Code:

int x;
int * const p2 = &x;

In the above, you cannot modify p2, but you can modify what p2 points to through p2.

This declares p3 to be a pointer to int that is constant and a null pointer:

Code:

int * const p1 = NULL;

If any of this is still unclear, I recommend watching Binky: Pointer Fun with Binky - YouTube

One way to look at the difference between declaration and dereference is to notice that this:

Code:

int *p = NULL;

defines the type of the expression *p (dereferencing), and the way the star is laid out helps show that in this case. I think.

Originally Posted by Romyo2

So if I'm not wrong, and from what you're telling about, I can do like this thing of coding:

Code:

int *p=10;
p=15;
printf("%d", p);

then it must print 15 without any errors, ye?

No:

• As I noted earlier, you should not be initialising pointers with integer constants or assigning integer constants to pointers unless you know that such initialisation/assignment is valid.
• The correct format specifier for printing a pointer with printf is %p, not %d. Furthermore, if the pointer is not a pointer to void, you should cast it to be a pointer to void.

Originally Posted by Romyo2

To the first note, why shouldn't I?

Here's what the C standard has to say about such a conversion:

Originally Posted by C11 Clause 6.3.2.3 Paragraph 5

An integer may be converted to any pointer type. Except as previously specified, the result is implementation-defined, might not be correctly aligned, might not point to an entity of the referenced type, and might be a trap representation.

The "except as previously specified" part has to do with null pointer constants since an integer constant expression with the value 0 is a null pointer constant.