Thread: pointers basic question

Hi,
i wanted clarification about pointers.

1) if i declare something like

Code:

 int *p ;

it creates pointer variable, which is not pointing to a variable yet, but would point to integer variable. so, if i access &p, is it a valid address or junk?
2) when i declare a void pointer like

Code:

 void *p1;

p1 then holds address of another variable, whose type is not known. Is this address
a valid one ? if so, does it mean that is points to a variable that could be 1 byte, 2 byte etc depending upon the the type?
3) Null pointer points to reserved space, which could be 0 . so, does NULL pointer have a type?
4)IN C, void to pointer type T is implicit. does it hold for void to NULL pointer too?
for example, can i have a function like this

Code:

  void * f(void)
            {
             some code

             return NULL;
            }

thanks

Hi Mk,
thanks for such detailed answer.

one last thing.

Not while p1 is uninitialized, since only by (very unlikely) coincidence would p1 actually hold the address of another variable.

so,this means, if pi was uninitialized, it would hold an address say 0x0002, which may not be assigned to a variable, and now, casting this pointer to NULL, would make this 0x0000?

Thank you once again
sedy

p1 holds an address, say 0x0002. That is a real memory address, but it (most likely) does not belong to you (the data there probably belongs to someone else).

You cannot cast a pointer to NULL.

If you assign p1 = NULL, then now the value of p1 is 0x0000. This does not affect the value of the memory at 0x0002.

Just a little more info/clarification:

Originally Posted by sed_y

1) if i declare something like

Code:

 int *p ;

it creates pointer variable, which is not pointing to a variable yet, but would point to integer variable. so, if i access &p, is it a valid address or junk?

If you're trying to "access" what p points to, then you want *p. Since p is uninitialized, you may find junk or you may crash your application by accessing memory you don't own. Technically, it's undefined behavior, which means anything or nothing is allowed to happen. It's bad juju, so don't do it.

2) when i declare a void pointer like

Code:

 void *p1;

p1 then holds address of another variable, whose type is not known. Is this address
a valid one ? if so, does it mean that is points to a variable that could be 1 byte, 2 byte etc depending upon the the type?

A void * can point to anything, but the compiler can never be sure of the type of thing it points to. To extend MK27's example:

Code:

char str[256];
p1 = str;  // p1 points to 256 byte char block
int x;
p1 = &x; // p1 points to an int
int y = *p1 + 3;  // The compiler doesn't know how to dereference a void * (i.e., it can't be sure of what's there)
y = *((int *) p1) + 3;  // This works, because you forced the compiler (by casting) to treat p1 as a pointer to an int, thus *p1 refers to an int

Note that casting will keep the compiler from producing warnings. This is fine if you're 100% sure of what you're doing, but if you mis-cast something, you can wreak havoc in your program's memory space. Use sparingly and be careful.

yes,
i meant p1=NULL, not casting to NULL, as casting would be to specify the type, and NULL does not have a type.
thanks

extending anduril's example

y = *((int *) p1) + 3;
y = *((char *) p1) + 3; // y is char

in first case, now, compiler knows to go forward 3 steps , but 3*4 bytes, for 4 byte int
and in second case, it goes 3 steps,=3 bytes. w/o casting, it would not know this.

Thank you all guys

I think the OP is confused about the meaning of NULL and void.

NULL might as well be zero for all practical purposes. A NULL pointer is one that contains address of zero (although some would argue there is nothing that mandates the exact value as long as the native system understands it as a special reserved value and acts accordingly). A pointer which holds such an address is to be interpreted as pointing to nothing. On purpose. The value is a place-holder. For example, the returned value from a failed file-open, or the failed allocation of a memory area. The expected value is an address that points to a file descriptor or memory area. A special value of zero indicates the function failed.

A "nul" is used as the last byte in a string. Sometimes said to be NULL terminated. Note different spelling: "nul" more accurately refers to ASCII character representation of all bits zero. Sure it's still a zero, mathematically speaking.

"void" is used for different things depending on context. In a function header, "void" instead of a formal parameter or return type means NO parameter and/or NO return value. On the other hand a void pointer is one that has no type. That is, no pointer arithmetic can be performed on it... there is no implicit size of elements.

thanks