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.

Practice

1. What does the malloc function do in C programming?

easy

A. Frees previously allocated memory

B. Allocates a block of memory on the heap

C. Declares a variable

D. Copies data from one memory location to another

Solution

1. Step 1: Understand the purpose of malloc

   malloc is used to allocate memory dynamically on the heap during program execution.

2. Step 2: Differentiate from other memory functions

   free releases memory, declaration creates variables, and copying data is done by functions like memcpy.

3. Final Answer:

   Allocates a block of memory on the heap -> Option B

4. Quick Check:

   malloc = Allocate memory [OK]

Hint: Remember: malloc = get memory, free = release memory [OK]

Common Mistakes:

• Confusing malloc with free
• Thinking malloc declares variables
• Assuming malloc copies data

2. Which of the following is the correct syntax to allocate memory for 10 integers using malloc?

easy

A. int *ptr = malloc(sizeof(int));

B. int *ptr = malloc(10);

C. int ptr = malloc(10 * sizeof(int));

D. int *ptr = malloc(10 * sizeof(int));

Solution

1. Step 1: Calculate total memory needed

   To allocate memory for 10 integers, multiply 10 by the size of an int: 10 * sizeof(int).

2. Step 2: Check pointer type and assignment

   The pointer must be of type int * and assigned the result of malloc. int *ptr = malloc(10 * sizeof(int)); matches this.

3. Final Answer:

   int *ptr = malloc(10 * sizeof(int)); -> Option D

4. Quick Check:

   Correct malloc size and pointer type = int *ptr = malloc(10 * sizeof(int)); [OK]

Hint: Multiply count by sizeof(type) for malloc size [OK]

Common Mistakes:

• Not multiplying by sizeof(int)
• Using wrong pointer type
• Allocating too little memory

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

int *ptr = malloc(4 * sizeof(int));
if (ptr == NULL) {
    printf("Allocation failed\n");
} else {
    ptr[0] = 10;
    ptr[1] = 20;
    printf("%d %d\n", ptr[0], ptr[1]);
    free(ptr);
}

medium

A. 10 20

B. 0 0

C. Allocation failed

D. Compilation error

Solution

1. Step 1: Check memory allocation and NULL condition

   The code allocates memory for 4 integers. If allocation fails, it prints "Allocation failed". Otherwise, it proceeds.

2. Step 2: Assign and print values

   Since allocation likely succeeds, ptr[0] = 10 and ptr[1] = 20 are set, then printed as "10 20".

3. Final Answer:

   10 20 -> Option A

4. Quick Check:

   Successful malloc prints assigned values [OK]

Hint: Check if malloc returns NULL before using pointer [OK]

Common Mistakes:

• Ignoring NULL check
• Assuming uninitialized values print zero
• Forgetting to free memory

4. Identify the error in this code snippet related to memory allocation:

char *str = malloc(5);
strcpy(str, "Hello World");
free(str);

medium

A. Memory allocated is too small for the string

B. Missing check if malloc returned NULL

C. Using strcpy without including

D. No error, code is correct

Solution

1. Step 1: Check allocated memory size

   Memory allocated is 5 bytes, but the string "Hello World" needs 12 bytes (11 chars + 1 null terminator).

2. Step 2: Understand consequences of insufficient memory

   Copying a larger string into smaller allocated space causes buffer overflow and undefined behavior.

3. Final Answer:

   Memory allocated is too small for the string -> Option A

4. Quick Check:

   Allocated size < string length = Memory allocated is too small for the string [OK]

Hint: Allocate enough space including null terminator [OK]

Common Mistakes:

• Ignoring string length vs allocated size
• Not checking malloc return value
• Assuming strcpy auto-expands memory

5. You want to allocate memory for an array of 5 integers, initialize them to zero, and then safely release the memory. Which code snippet correctly implements this flow?

hard

A. int *arr = malloc(5 * sizeof(int));
for(int i=0; i<5; i++) arr[i] = 0;

B. int arr[5];
for(int i=0; i<5; i++) arr[i] = 0;

C. int *arr = calloc(5, sizeof(int));
free(arr);

D. int *arr = malloc(5);
memset(arr, 0, 5 * sizeof(int));
free(arr);

Solution

1. Step 1: Understand memory allocation and initialization

   calloc allocates and initializes memory to zero automatically, perfect for this task.

2. Step 2: Check safe memory release

   free(arr); correctly releases the allocated memory after use.

3. Final Answer:

   int *arr = calloc(5, sizeof(int)); free(arr); -> Option C

4. Quick Check:

   calloc zero-initializes and malloc does not [OK]

Hint: Use calloc for zero-initialized memory allocation [OK]

Common Mistakes:

• Using malloc without initializing memory
• Allocating too little memory
• Not freeing dynamically allocated memory