Understanding concept of free

Question

Tried the following code :

#include<stdio.h>
int main()
{        
        int *p,*q;
        p = (int *)malloc(sizeof(int));
        *p =10;
        q = p;
        printf("%u \n",p);
        printf("%u \n",q);
        free(p);
        printf("%u \n",p);
        return 0;
}

The output got is as follows :

[root@lnxdesk Tazim]# ./a.out
154804232
154804232
154804232

Why is that address inside p is still printed even if I have done free(p);? What has free(p) done then?

I want to understand the concept of free/malloc clearly. Any help will be valuable.

score 5 · Accepted Answer · edited Jan 07 '15 at 23:27

5

free() only frees the memory on the heap. It does not change the value of your pointer. If you tried to print the memory pointed by your pointer, you'll probably get some kind of garbage.

Also, when you called free, you gave it the pointer, not the address to your pointer, so free can't change your pointer...

edited Jan 07 '15 at 23:27

AndersTornkvist

2,610
20
38

answered Mar 21 '11 at 12:03

MByD

135,866
28
264
277

That's true, but printing the pointer value is still undefined behavior - http://stackoverflow.com/q/4076563/57428 – sharptooth Mar 21 '11 at 12:06

score 3 · Answer 2 · edited May 23 '17 at 11:55

3

That's undefined behavior - once you've freed the pointer the address stored becomes invalid and you can't do anything with it - not only you can't dereference it, but you can't even printf() the pointer value.

edited May 23 '17 at 11:55

Community

1
1

answered Mar 21 '11 at 12:02

sharptooth

167,383
100
513
979

This doesn't technically answer the question. – JUST MY correct OPINION Mar 21 '11 at 12:18
@JUST MY correct OPINION: It does - once you've done `free()` you can't print the address - it can produce any results. – sharptooth Mar 21 '11 at 12:22
The question was "Why is that address inside p is still printed even if I have done free(p); What has free(p) done than ? Want to understand the concept of free/malloc clearly." You didn't answer either part of that. – JUST MY correct OPINION Mar 21 '11 at 12:26
@JUST MY correct OPINION: UB means "anything can happen", including printing the same address as previously. – sharptooth Mar 21 '11 at 12:29
Well except that part alone is nonsense. The pointer will not change from a `free()` ever -- you're passing the pointer, not the address of the pointer. So not "anything can happen": the pointer cannot change. – JUST MY correct OPINION Mar 21 '11 at 12:44
@JUST MY correct OPINION: The pointer will no change, but it will no longer be a valid pointer. – sharptooth Mar 21 '11 at 12:56
Which means pretty much by definition it's going to be printing out the same address, no? – JUST MY correct OPINION Mar 21 '11 at 14:40
@JUST MY correct OPINION: No, printing an invalid address is undefined behavior. – sharptooth Mar 21 '11 at 14:43

Sylvain · Answer 3 · 2011-04-13T16:59:12.890

2

You are printing the pointers, i.e. the address of the memory zones allocated for you ints. Freeing a memory zone with free does not set the pointer's address to 0x00 as I think you expect.

It just tells the OS that the memory zone is available again for future re-use.

If you were printing *p after free(p), you would have problems.

edited Apr 13 '11 at 16:59

answered Mar 21 '11 at 12:04

Sylvain

1,553
11
15

You should edit your answer and remove "Printing p is fine ..." as it is undefined behavior. – Jens Apr 13 '11 at 11:27

score 1 · Answer 4 · answered Mar 21 '11 at 12:08

malloc() and its ilk reserve space in a memory storage area called the "heap" and return a pointer to that reserved area. So in your sample above p is given a pointer to, probably, a four-byte memory region that has been reserved for its use (whose address happens to be 154804232 this time around). When you do *p = 10 you are now placing the integer value 10 into the memory pointed to. When you do q = p you're now making q point to the same chunk of reserved heap memory.

free() and its ilk just unreserve the memory. When you call free() you're saying "I'm not going to use this memory anymore". All free() does is tell the memory management system that the block of memory is now available for use once again. It emphatically does not change your pointer. It just signals that the block of memory is available. After that it is up to you to ensure that you do not use that pointer again.

If you do use that pointer again it may work fine. Once. Or twice. Or a thousand times. It'll work fine, basically, until you use it after someone else claims that memory block you've said is free and does something with it. When that transpires, Bad Things Happen<tm>. Please don't make bad things happen.

Raveline · Answer 5 · 2011-03-21T12:18:40.083

0

Remember : a pointer is nothing but an address. Before, after your malloc, or free, it'll give you the same result. The only thing that malloc() does is reserve space at this address. The only thing that free does is release it (most probably, mark this address as usable to store other things, "cleaning" would be time consuming). This is why putting your pointer to NULL after a free is a good idea ; because you can be sure if the pointer is connected to something or not.

edited Mar 21 '11 at 12:18

answered Mar 21 '11 at 12:05

Raveline

2,660
1
24
28

`malloc()` doesn't store anything at the address it returns. – JUST MY correct OPINION Mar 21 '11 at 12:09
Err... maybe it's my english that's rotten. What difference would you make between "storing" and "reserving space" ? – Raveline Mar 21 '11 at 12:14
Reserving space means telling the memory management system "don't give this memory out to anybody else". Storing would mean actually putting some value into that space. – JUST MY correct OPINION Mar 21 '11 at 12:17

dubnde · Answer 6 · 2011-03-21T13:49:20.097

free does not reassign the pointer to point to something else. In fact, the C standard does not mention anything be done with the pointer. This is all it says in the description:

The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if the argument does not match a pointer earlier returned by the calloc, malloc, or realloc function, or if the space has been deallocated by a call to free or realloc, the behavior is undefined

Understanding concept of free

6 Answers6