free function - Step-by-Step Execution

Concept Flow - free function

Allocate memory with malloc

↓

Use the allocated memory

↓

Call free to release memory

↓

Memory is returned to system

↓

Pointer becomes invalid

↓

Avoid using pointer after free

This flow shows how memory is allocated, used, freed, and then the pointer becomes invalid to prevent errors.

Execution Sample

C

#include <stdlib.h>

int *p = malloc(sizeof(int));
*p = 10;
free(p);
p = NULL;

This code allocates memory for an int, stores 10, frees the memory, and sets pointer to NULL.

Execution Table

Step	Action	Pointer p	Memory State	Notes
1	Allocate memory with malloc	p -> valid address	Memory allocated for int	p points to allocated memory
2	Store value 10 at *p	p -> valid address	Memory contains 10	Value stored in allocated memory
3	Call free(p)	p -> dangling pointer	Memory freed	Memory returned to system, p still points but invalid
4	Set p = NULL	p = NULL	No allocated memory pointed	Pointer reset to avoid dangling pointer

💡 Pointer p is set to NULL to avoid using freed memory which would cause errors.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
p	uninitialized	valid address	valid address	dangling pointer	NULL

Key Moments - 2 Insights

Why do we set the pointer to NULL after calling free?

After free (see step 3 in execution_table), the pointer still holds the old address but that memory is invalid. Setting it to NULL (step 4) prevents accidental use of invalid memory.

What happens if we use the pointer after free without setting it to NULL?

Using a pointer after free (dangling pointer) can cause crashes or unpredictable behavior because the memory is no longer valid, as shown in step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of pointer p immediately after calling free(p)?

A p is NULL

B p points to valid allocated memory

C p is a dangling pointer pointing to freed memory

D p is uninitialized

💡 Hint

Check step 3 in execution_table where free is called and pointer state is described.

At which step does the memory get returned to the system?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Memory State' column in execution_table for when memory is freed.

If we skip setting p = NULL after free, what risk do we face?

A Memory leak

B Using invalid memory (dangling pointer)

C Pointer becomes NULL automatically

D No risk, safe to use pointer

💡 Hint

Refer to key_moments about pointer state after free and why NULL assignment is important.

Concept Snapshot

free function in C:
- Use free(pointer) to release malloc'ed memory
- After free, pointer becomes dangling (invalid)
- Always set pointer to NULL after free
- Avoid using pointer after free to prevent crashes
- Proper memory management prevents leaks and errors

Full Transcript

In C programming, when you allocate memory dynamically using malloc, you must release it using the free function. The flow starts with allocating memory, then using it, then calling free to release it back to the system. After free, the pointer still holds the old address but that memory is invalid, so it is a dangling pointer. To avoid errors, set the pointer to NULL after freeing. Using a pointer after free without resetting it can cause crashes or unpredictable behavior. This example code shows allocating an int, storing 10, freeing the memory, and setting the pointer to NULL. The execution table traces each step, showing pointer state and memory state. Key moments clarify why setting pointer to NULL is important and the risks of using freed memory. The visual quiz tests understanding of pointer states and memory management steps. Remember, always free what you malloc and then reset your pointer to NULL.