Pointer headache

Printable View

07-29-2002
dv007

Pointer headache

Dear all Sir:
I am confused between Legal address and none-Legal
address POINTER. For example below:

int a;
int *pt = NULL; /* pt does not hold a legal address */
int *q = &a; /* q hold a legal address */

printf("address of pt is %p", pt);
printf("address of a is %p", &a);
printf("address of q is %p", q);

But when run this code segment, pt holds a perfect memory address. Why many books say that the case
int *pt = NULL hold none-legal address?
In this scenerio, What non-legal address mean?
Any C experts can explain concisely about this.
Thanx for a million.
DV007
07-29-2002
moi

it isnt a legal address. I'm curious what you get when you run this program
07-29-2002
Cshot

pt holds a NULL address(it'll most likely output a 0). You will get unexpected results if you try to mess with that address because it's not a legal one meaning it's not for your use.

q holds a legal address since it stores the address of a. Int a was allocated by your program therefore it is legal and safe to use that location up to sizeof(int).
07-29-2002
Hammer

>But when run this code segment, pt holds a perfect memory address.
What's a "perfect memory address"? As already stated, it will hold NULL.
07-30-2002
dv007

Quote:

Originally posted by Cshot
pt holds a NULL address(it'll most likely output a 0). You will get unexpected results if you try to mess with that address because it's not a legal one meaning it's not for your use.

q holds a legal address since it stores the address of a. Int a was allocated by your program therefore it is legal and safe to use that location up to sizeof(int).

Thanx for your explaining, Cshot.
I have one more question that what about int *ptr?
does int *ptr holds non-legal address too?
int *ptr; /* a none initialize pointer */

DV007
07-30-2002
Sayeh

Okay, okay, let's get our head around 'compiler jargon' a little bit. The confusion is in the way you are looking at the terms.

Remember, C/C++ is written according to specific grammar rules. This is called 'syntax'.

When the compiler says 'non-legal' address it means that it is an address that is effectively 'out of bounds' for your use. Either no such physical/virtual address of that value is accessible, or you are trying to access something on 'zero page' (low RAM where the O/S works).

Using your example:

Code:

int a; int *pt = NULL; /* pt does not hold a legal address */ int *q = &a; /* q hold a legal address */

When you declare 'a', upon execution, the space for this integer variable is determined and known. Let's just say that 'a' is an integer (2-bytes) worth of RAM at location 0x00315D3A.

Like so:

Code:

Address Bytes ------------------------------------------------------------------------------------------------- 00315D3A 00 00 <-- 2 bytes (16 bits) 00315D3C EF 31 D4 55 3A B2 32 61 <-- RAM with random values 00315D44 00 00 2D 01 00 3A DD 74 <-- RAM with more random values.

When you say 'int *pt = NULL', you are stuffing a zero (long) into 'pt'. This is a valid value. If you poke anything into location zero it RAM, either the O/S won't allow you to (protected memory), or you will screw something up (scrambling valid data already there). It is an illegal address because you're not supposed to access it, but it's a valid value, so the program will still run, although the compiler gives you a warning.

When you say 'int *q = &a', of course this is legal because &a = 0x00315D3A, so 'q' now points to that location in RAM.

Any value might be at that location, until _you_ specifically initialize it something difference (such as with q[0] = 0x0000;).
07-30-2002
dv007

Thanks for your expertised explaining, Sayeh.
but how about a non-initialized pointer?
For example:

int *iptr; /* these are non-initialized pointer
float *fptr; /* variables and I guess non-legal*/

printf("address of iptr is: %p ", iptr);
printf("address of fptr is: %p", fptr);

Since base on C books,both above pointer variables
hold non-legal addresses. But actually it outputs
perfect address for both. Each pointer hold a
different perfect 32-bit address on my PC. So why C called them "illegal" addresspointers?:confused:

Code:

_______iptr int *iptr; represent |0xff03|----> int -------- _______fptr float *fptr; represent |0xfff8|----> float --------

Is my illustration for 2 pointer variables above
is right? Please correct me if I am wrong.

DV007
07-31-2002
moi

Quote:

Originally posted by dv007

Since base on C books,both above pointer variables
hold non-legal addresses. But actually it outputs
perfect address for both. Each pointer hold a
different perfect 32-bit address on my PC. So why C called them "illegal" addresspointers?:confused:

DV007

because they're someone else's address space. your program doesnt have the rights to use that space. just imagine what things would be like if anything was allowed to write anywhere in ram and there were no controls on who's ram is whos. you wouldnt be able to run a program safely because other programs would always be overwriting it's data.
07-31-2002
Salem

Ok, start with

int *pt; /* pt is uninitialised and invalid */

What this means is that you cannot do something like
*pt = 42;
until you've initialised the pointer.
You don't know where this is pointing, so it's down to chance as to wether this would work or crash. Even if it happens to work, the program is still wrong.

int *pt = NULL; /* pt is initialised, but invalid */

A NULL pointer is a place where you can never store a value (or read a value). If you tried
*pt = 42;
you would be guaranteed to get a segmentation fault (in some environments at least).

int a;
int *pt = &a; /* pt is initialised, and valid */
In this case, doing
*pt = 42;
is a perfectly valid thing to do

> int *iptr; /* these are non-initialized pointer
> float *fptr; /* variables and I guess non-legal*/
> printf("address of iptr is: %p ", iptr);
> printf("address of fptr is: %p", fptr);
You can print any pointer you like using this code, since this is not a test of the validity of a pointer.
The validity of a pointer is determined by whether you can dereference it or not (see above)
In this case, the pointer is uninitialised, so doing
*iptr = 42;
is wrong.
08-01-2002
Sayeh

Adding a little to Salem's work,

[code]
int *iptr; /* these are non-initialized pointer
float *fptr; /* variables and I guess non-legal*/

printf("address of iptr is: %p ", iptr);
printf("address of fptr is: %p", fptr);
[code]

The question is: Just where _exactly_ does 'iptr' and 'fptr' point to? Make sure you are not confusing the address of where the variable resides in memory with the contents of the pointer.

'iptr' sits at a specific location in RAM, decided by relative positioning by your compiler and resolved at execution by your link loader.

For example, let's say that 'iptr' and 'fptr' reside _at_ consecutive memory locations:

Code:

Address RAM ------------------------------------------------------------ 0x004A72E1 FF 03 FF F8 A5 71 24 EE 0x004A72E9 F1 23 A7 EE 64 51 29 20 ...

In the above case, 'iptr' is located at 0x004A72E1. This is the value of iptr (it's ADDRESS) aka where it lives in RAM. If I go indirectly through that address = 'a = *iptr', where 'a' is an int, it will make the contents of a equal to 'FF 03'. This is a negative number.

So when the program starts up, if you have not _initialized_ your variable 'iptr' and 'fptr' to something else (like zero), it will contain whatever value happens to be in RAM at the time.

RAM is not all zeroes.

If program 'A' quits and then your program 'B' executes and is thereby loaded into the memory that program 'A' was previously in, the O/S and the memory manager DON'T clean RAM up. Why would they? It's up to you to zero and clean and maintain space you intend to use.

So, if program 'A' left the Value 0xFF03 at location 0x004A72E1, and your program happens to have variable 'iptr' loaded at that address, its value is going to be 0xFF03 until _you_ specifically set it to something else.

That is _specifically_ why I initialize every pointer I create to zero (NULL) prior to its use. When I deallocate dynamic allocations, I reset their pointers to zero. That way, I can always tell if I'm using a valid pointer by check it against a known state.

Everytime I go to use a pointer, the first thing I do is check to see if it's valid.

Code:

... if(!myPtr) /* ptr has been allocated? */ return(errCODE); /* nope, bail */ ...

If it's non-zero, I have a very good bet that it's a valid pointer. The only other possibility is that some poorly behaved program has rampaged through my RAM and corruped a nil pointer such that it contains something other than NULL.
08-01-2002
Sayeh

Sorry, I screwed the tags up on the previous. This should be easier to read.

Code:

int *iptr; /* these are non-initialized pointer float *fptr; /* variables and I guess non-legal*/ printf("address of iptr is: %p ", iptr); printf("address of fptr is: %p", fptr);

The question is: Just where _exactly_ does 'iptr' and 'fptr' point to? Make sure you are not confusing the address of where the variable resides in memory with the contents of the pointer.

'iptr' sits at a specific location in RAM, decided by relative positioning by your compiler and resolved at execution by your link loader.

For example, let's say that 'iptr' and 'fptr' reside _at_ consecutive memory locations:

Code:

Address RAM ------------------------------------------------------------ 0x004A72E1 FF 03 FF F8 A5 71 24 EE 0x004A72E9 F1 23 A7 EE 64 51 29 20 ...

In the above case, 'iptr' is located at 0x004A72E1. This is the value of iptr (it's ADDRESS) aka where it lives in RAM. If I go indirectly through that address = 'a = *iptr', where 'a' is an int, it will make the contents of a equal to 'FF 03'. This is a negative number.

So when the program starts up, if you have not _initialized_ your variable 'iptr' and 'fptr' to something else (like zero), it will contain whatever value happens to be in RAM at the time.

RAM is not all zeroes.

If program 'A' quits and then your program 'B' executes and is thereby loaded into the memory that program 'A' was previously in, the O/S and the memory manager DON'T clean RAM up. Why would they? It's up to you to zero and clean and maintain space you intend to use.

So, if program 'A' left the Value 0xFF03 at location 0x004A72E1, and your program happens to have variable 'iptr' loaded at that address, its value is going to be 0xFF03 until _you_ specifically set it to something else.

That is _specifically_ why I initialize every pointer I create to zero (NULL) prior to its use. When I deallocate dynamic allocations, I reset their pointers to zero. That way, I can always tell if I'm using a valid pointer by check it against a known state.

Everytime I go to use a pointer, the first thing I do is check to see if it's valid.

Code:

... if(!myPtr) /* ptr has been allocated? */ return(errCODE); /* nope, bail */ ...

If it's non-zero, I have a very good bet that it's a valid pointer. The only other possibility is that some poorly behaved program has rampaged through my RAM and corruped a nil pointer such that it contains something other than NULL.
08-01-2002
dv007

Thank you very much for relieving my pointer headache. You guys really C experts. Hope to discuss with you guys again in the future.
Muncho gracias!
DV007