Memory allocation flow - Step-by-Step Execution

Concept Flow - Memory allocation flow

Start Program

↓

Request Memory Allocation

↓

Check Available Memory

Yes No↓

Allocate Memory

↓

Use Memory

↓

Free Memory

↓

End Program

This flow shows how a program requests memory, checks availability, allocates if possible, uses it, then frees it.

Execution Sample

C

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

int main() {
    int *p = malloc(sizeof(int));
    if (p == NULL) return 1;
    *p = 10;
    free(p);
    return 0;
}

This code allocates memory for an int, checks if allocation succeeded, assigns a value, then frees the memory.

Execution Table

Step	Action	Evaluation	Result
1	Call malloc(sizeof(int))	Memory available?	Pointer p assigned address or NULL
2	Check if p == NULL	Is allocation successful?	If yes, proceed; if no, exit with error
3	Assign *p = 10	Store value 10 at allocated memory	Memory content updated
4	Call free(p)	Release allocated memory	Memory returned to system
5	Return 0	Program ends successfully	Exit program

💡 Program ends after freeing memory and returning 0

Variable Tracker

Variable	Start	After malloc	After assignment	After free	Final
p	undefined	address or NULL	address (value 10 stored)	address (memory freed)	undefined

Key Moments - 3 Insights

Why do we check if p == NULL after malloc?

Because malloc returns NULL if memory allocation fails, so checking p == NULL (see execution_table step 2) prevents using invalid memory.

What happens if we forget to call free(p)?

The allocated memory stays reserved and is not returned to the system, causing a memory leak (see execution_table step 4).

Can we use *p before malloc?

No, because p does not point to valid memory before malloc (see variable_tracker start value). Using it causes undefined behavior.

Visual Quiz - 3 Questions

Look at the execution_table, what does malloc return if memory is not available?

A Zero

B A valid memory address

C NULL

D An error code

💡 Hint

Check execution_table row 1 and 2 about malloc and p == NULL

At which step is the allocated memory released back to the system?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

See execution_table step 4 about free(p)

If we skip the check 'if (p == NULL)', what could happen?

A Program crashes or behaves unpredictably

B Memory is freed twice

C Memory allocation is faster

D Nothing changes

💡 Hint

Refer to key_moments about checking p == NULL and safe memory use

Concept Snapshot

Memory allocation flow in C:
- Use malloc() to request memory
- Check if malloc returns NULL (allocation failed)
- Use allocated memory safely
- Free memory with free() to avoid leaks
- Always check pointers before use

Full Transcript

This visual execution shows how memory allocation works in C. The program starts and calls malloc to request memory. It checks if malloc returned NULL, meaning allocation failed. If successful, it uses the memory by storing a value. Then it frees the memory to return it to the system. Finally, the program ends. Variables like pointer p change from undefined to a valid address after malloc, then back to undefined after free. Key points include always checking malloc's return and freeing memory to avoid leaks.