Thread: Freeing memory

Hello!
I have a doubt about how the operation of freeing memory works.
If i write a program like this one:

Code:

#include <stdio.h>
#include <stdlib.h>

struct orderlistNode {
	int number;
	struct orderlistNode* nextNode;
};

typedef struct orderlistNode* orderNode;

int main(){

	orderNode a = malloc(sizeof(struct orderlistNode));
	orderNode b = malloc(sizeof(struct orderlistNode));
	a->number = 47;
	b->number = 2;
	a->nextNode = b;

	printf("a: %d\n", a->number);
	printf("b: %d\n", b->number);

	free(a);

	printf("again a: %d\n", a->number);
	printf("through a: %d\n", a->nextNode->number);
	printf("again b: %d\n", b->number);

	return 0;
}

even after freeing the variable 'a' I'm able to read it and even to navigate the list through its internal pointer! Is it normal? And if it is, how can I free the variable 'a' in a way that it can't be accessed anymore?
Thanks for your help!

Thanks for all the answers!

Originally Posted by nonoob

BEFORE you free that memory you should zero it out. Being careful to only assign the correct size of data. Could be a = 0 (for int), or memset(&a, 0, 1000) for 1000 bytes worth. Then you use free().

For your example:

Code:

memset(a, 0, sizeof(struct orderlistNode));
free(a);

This is to avoid that, if the memory is later assigned to another variabile, the variable will be pre-allocated with the old values in that memory space?

This is to avoid that, if the memory is later assigned to another variabile, the variable will be pre-allocated with the old values in that memory space?

Maybe or maybe not. Anyway you SHOULD NOT be relying on such behavior.

Originally Posted by nonoob

Yes. Freeing memory does not automatically zero out its contents. It will be reused when the system needs it. It should NOT be depended upon to retain any data though. Things could change in there any time because it has been designated as available.

Computers save time by not writing any superfluous data, such as zeroes, to storage that is marked as "free". Just like on hard-drives, where old data can sometimes be recovered from so called erased files. Why write stuff when there's usually no expectation that anyone would want to read it.

Could this come back to bite you later?

My situation, in a string manipulation function, is that I make some copies of strings with strncpy or strncat into a string called second_str and so forth. I would then free said string of size n at the end of the function.

I would later make repeated calls to that function and malloc space for the same string name of same size n called second_str, but instead copy n-3 chars into it. Upon printing it, i would see the original last 3 chars of the previous string when the function was used previously.

Could this be why it does that?

Thanks again!
One last question: freeing my variable 'a' in the example of the first post doesn't free also the 'b' variable pointed by its internal field, am I right?