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.

Practice

1. What is the main purpose of the free function in C?

easy

A. To initialize a pointer to NULL

B. To allocate new memory dynamically

C. To copy data from one memory location to another

D. To release memory previously allocated by malloc or similar functions

Solution

1. Step 1: Understand what free does

   The free function releases memory that was allocated dynamically, returning it to the system.

2. Step 2: Differentiate from other memory functions

   malloc allocates memory, free releases it. Copying or initializing pointers is unrelated.

3. Final Answer:

   To release memory previously allocated by malloc or similar functions -> Option D

4. Quick Check:

   free releases memory = A [OK]

Hint: Remember: free returns memory, malloc gets memory [OK]

Common Mistakes:

• Confusing free with malloc or calloc
• Thinking free allocates memory
• Using free to copy data

2. Which of the following is the correct way to free memory allocated by malloc?

easy

A. free(pointer); pointer = NULL;

B. free(pointer); free(pointer);

C. free(pointer); pointer++;

D. free(pointer); pointer = malloc(10);

Solution

1. Step 1: Free the allocated memory

   Calling free(pointer); releases the memory correctly.

2. Step 2: Avoid dangling pointer

   Setting pointer = NULL; after freeing prevents accidental use of freed memory.

3. Final Answer:

   free(pointer); pointer = NULL; -> Option A

4. Quick Check:

   Free then NULL pointer = D [OK]

Hint: Always set pointer to NULL after free to avoid bugs [OK]

Common Mistakes:

• Calling free twice on the same pointer
• Incrementing pointer after free
• Reassigning pointer without freeing first

3. What will be the output of this C code?

char *ptr = malloc(5);
strcpy(ptr, "test");
free(ptr);
printf("%s", ptr);

medium

A. test

B. Undefined behavior (may print garbage or crash)

C. Compilation error

D. Empty string

Solution

1. Step 1: Analyze memory allocation and free

   Memory is allocated and string "test" copied. Then memory is freed.

2. Step 2: Using pointer after free

   Printing ptr after free causes undefined behavior; it may print garbage or crash.

3. Final Answer:

   Undefined behavior (may print garbage or crash) -> Option B

4. Quick Check:

   Using freed pointer = undefined behavior [OK]

Hint: Never use pointer after free without reassigning [OK]

Common Mistakes:

• Assuming freed pointer still holds valid data
• Expecting compilation error
• Thinking it prints empty string

4. Identify the error in this code snippet:

int *arr = malloc(3 * sizeof(int));
free(arr + 1);

medium

A. free called on pointer not returned by malloc

B. Missing free call

C. Incorrect size in malloc

D. No error, code is correct

Solution

1. Step 1: Understand pointer passed to free

   Memory was allocated at arr, but free is called on arr + 1, which is not the original pointer.

2. Step 2: Free must be called on original pointer

   Only the pointer returned by malloc (or NULL) can be passed to free safely.

3. Final Answer:

   free called on pointer not returned by malloc -> Option A

4. Quick Check:

   Free must use original pointer = A [OK]

Hint: Free only original malloc pointer, not offset pointers [OK]

Common Mistakes:

• Freeing pointer offset from malloc result
• Not freeing allocated memory
• Assuming free can take any pointer inside block

5. You have a function that reallocates memory for an integer array:

int *resize(int *arr, int new_size) {
    int *temp = realloc(arr, new_size * sizeof(int));
    if (temp == NULL) {
        free(arr);
        return NULL;
    }
    return temp;
}

What is the best practice to avoid memory leaks when using this function?

hard

A. Always free the original pointer before calling resize

B. Call free on the returned pointer immediately after resize

C. Assign the return value to a temporary pointer before updating original pointer

D. Do not check if realloc returns NULL

Solution

1. Step 1: Understand realloc behavior

   If realloc fails, it returns NULL and original memory remains allocated.

2. Step 2: Use temporary pointer to avoid losing original memory

   Assign realloc result to a temp pointer first; if NULL, free original to avoid leaks.

3. Final Answer:

   Assign the return value to a temporary pointer before updating original pointer -> Option C

4. Quick Check:

   Use temp pointer for realloc to prevent leaks = B [OK]

Hint: Use temp pointer for realloc result before replacing original [OK]

Common Mistakes:

• Overwriting original pointer without checking realloc result
• Freeing original pointer before realloc
• Ignoring NULL return from realloc