simple question on pointers

[aivars1]

hello,
i have started to learn C. The code below is from Lesson 6 here on this site tutorial. It compiles and runs OK.
After the code has been run is the pointer still pointing to the integer and pc memory not freed?
Using Windows XP and Bloodshed Dev++ compiler.

Thanks,
aivars

#include <stdio.h>

int main()
{ 
    int x;            /* A normal integer*/
    int *p;           /* A pointer to an integer ("*p" is an integer, so p
                       must be a pointer to an integer) */

    p = &x;           /* Read it, "assign the address of x to p" */
    scanf( "%d", &x );          /* Put a value in x, we could also use p here */
    printf( "%d\n", *p ); /* Note the use of the * to get the value */
    getchar();
}

[King Mir]

The integer is on the stack. It will be invalidated when the containing function, in this case main(), returns. The stack as a whole is allocated to your program starts, and freed when your program ends. You do not need to and should not try to free anything on the stack. Only things allocated with malloc() and calloc() need to be freed by the program explicitly.

Also all memory is automatically freed when a program terminates in any modern OS.

[aivars1]

Thanks a lot,
The reason for asking was that I modified the code to see the address of x (&x or p) is. And every time I run the code I get the same number - 2293620. Even after rebooting, after three days etc. I thought the address is assigned randomly and the number should change.
I compiled the code on Linux (Ubuntu Hardy) and here the memory address of x changes after each run. It is is different format though and starts with - sign which also I do not understand why e.g -1075170336.
Is it compiler who determines what memory address should be used? On linux I use gcc compiler but I understand Bloodshed Dev++ also uses kind of GCC.
Or am I missing something big here?

thanks,
aivars

[Dino]

If you print out the address of x using the %p (pointer) formatting option instead of %d (signed integer), you won't get a sign.

[IceDane]

Keep in mind that freeing memory does not, in almost all cases, mean that the memory is zeroed or over-written. The memory manager simply marks the memory as available - it does not need to overwrite what's already there with nulls or anything similar as it'll be overwritten as he uses it.

As to the address thing, that depends on what you're running at the time really. If you're using a lot of your ram, you can expect the address being different. But I assume that most of the time when you sit and program, you're running the same basic applications, so it wouldn't be strange if the address is the same.

Perhaps someone can shed some more light on this and give a more detailed explanation.

[cas]

There's no reason to expect that, by necessity, the addresses of your functions/objects will change between runs. On virtual memory systems, each process thinks the entire address space of the machine belongs to it, so there's no problem using fixed addresses. For example, try:

int main(void)
{
  printf("%p\n", (void *)main);
}

Not perfectly legal code, but that's OK, because on the systems we're interested in, it will work. On my system, main stays in the same place each time, which is perfectly fine, because regardless of where it resides in physical memory, it knows that this particular location will always be free in the virtual address space.

As for why local variables keep changing on Ubuntu, that's likely because your system randomizes the stack, for security purposes. Look in /proc/sys/kernel/randomize_va_space; it's probably set to 1 or 2. If you do

echo 0 > /proc/sys/kernel/randomize_va_space

and run your program a few times, odds are that your local variable will remain in the same location. Don't forget to set randomize_va_space back to its original value if you're so inclined.

I think the most important thing to take away here is the idea that virtual memory is more than just using drive space to supplement RAM. While that is indeed an optional part of a virtual memory system, the fundamental part of VM is that each process is under the illusion that it is the only program on the system and that it has free range over memory. In reality, all the (virtual) addresses the program sees are translated into physical addresses, so it can share with everybody else. Thus the illusion is maintained.

[aivars1]

thanks to all who responded.
I see I have a long way to go...

aivars

[matsp]

The reason that your address is negative on Linux is that the stack is allocated at a high memory address, which is above the 0x80000000 (2GB), in fact the number you gave is BFEA33E0, which is just under 3GB. Since the highest bit of a signed integer is the sign, anything above 2GB is "negative" if you interpret it as a signed integer.

As suggested, using %p will show a hexadecimal, unsigned value representing the address.

--
Mats

[robwhit]

As suggested, using %p will show a hexadecimal, unsigned value representing the address.

Strictly speaking, it would show an implementation-defined sequence of printable characters, not necessarily in that format.