realloc function - Step-by-Step Execution

Concept Flow - realloc function

Start with pointer p

↓

Call realloc(p, new_size)

↓

Check if realloc returned NULL?

Yes→Handle error, keep old p

No↓

p now points to resized memory

↓

Use resized memory

↓

Free memory when done

The realloc function tries to resize a memory block pointed by p. If successful, it returns a new pointer; if it fails, it returns NULL and the old pointer remains valid.

Execution Sample

C

int *p = malloc(2 * sizeof(int));
p[0] = 10; p[1] = 20;
int *temp = realloc(p, 4 * sizeof(int));
if (temp != NULL) {
    p = temp;
    p[2] = 30; p[3] = 40;
} else {
    // Handle realloc failure
}

This code allocates memory for 2 integers, stores values, then resizes to hold 4 integers and adds more values safely by checking realloc's return value.

Execution Table

Step	Action	Pointer p	Memory Size	Result/Notes
1	malloc(2 ints)	p -> block1	2 ints	Memory allocated for 2 ints
2	Assign p[0]=10, p[1]=20	p -> block1	2 ints	Values stored in memory
3	realloc(p, 4 ints)	p -> block2 or block1	4 ints	Memory resized, pointer updated if successful
4	Assign p[2]=30, p[3]=40	p -> block2 or block1	4 ints	New values stored in resized memory

💡 Execution ends after storing new values in resized memory block

Variable Tracker

Variable	Start	After malloc	After realloc	Final
p	NULL	Address block1	Address block2 or block1	Address block2 or block1
Memory Size	0	2 ints	4 ints	4 ints

Key Moments - 3 Insights

What happens if realloc returns NULL?

If realloc returns NULL (see step 3 in execution_table), the original pointer p is still valid and points to the old memory. You must not overwrite p without checking, or you lose the reference to allocated memory causing a memory leak.

Does realloc always move memory to a new location?

No, realloc may resize the memory in place (p points to same block) or move it to a new block (p points to new block). This is why p must be assigned the return value of realloc.

Why assign p = realloc(p, new_size) instead of just calling realloc(p, new_size)?

Because realloc returns the new pointer to the resized memory. If you don't assign it, you won't know the new location and may access invalid memory.

Visual Quiz - 3 Questions

Look at the variable_tracker table, what is the value of p after realloc?

A Same as after malloc or new address

B NULL

C Unchanged NULL

D Undefined

💡 Hint

Check 'After realloc' column for variable p in variable_tracker

At which step in execution_table is the memory resized?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for realloc call in execution_table

If realloc fails and returns NULL, what should you do to avoid losing the original memory?

A Assign p = realloc(p, new_size) without check

B Free p immediately

C Use a temporary pointer to store realloc result first

D Ignore the return value

💡 Hint

Refer to key_moments about handling realloc failure

Concept Snapshot

realloc(pointer, new_size) resizes memory block.
Returns new pointer or NULL if fails.
Always assign result to a temp pointer first.
If NULL, old pointer is still valid.
Use realloc to grow or shrink allocated memory.

Full Transcript

The realloc function in C changes the size of a memory block pointed to by a pointer. First, you allocate memory with malloc. Then you can call realloc to resize that memory. realloc returns a new pointer to the resized memory or NULL if it fails. If it returns NULL, the original pointer remains valid and must not be overwritten to avoid memory leaks. Always check realloc's return value before assigning it to your pointer. This example shows allocating memory for 2 integers, storing values, then resizing to hold 4 integers and adding more values. The execution table traces each step, showing how the pointer and memory size change. Key moments clarify common confusions about realloc's behavior and safe usage.

Practice

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

easy

A. It allocates a new memory block without preserving old data.

B. It frees the allocated memory block immediately.

C. It changes the size of a previously allocated memory block, preserving its content.

D. It copies data from one memory block to another.

Solution

1. Step 1: Understand the purpose of realloc

   The realloc function is used to resize an existing memory block allocated by malloc or calloc.

2. Step 2: Check data preservation behavior

   realloc preserves the existing data up to the minimum of old and new sizes.

3. Final Answer:

   It changes the size of a previously allocated memory block, preserving its content. -> Option C

4. Quick Check:

   realloc resizes memory and keeps data [OK]

Hint: Remember: realloc resizes and keeps old data safe [OK]

Common Mistakes:

• Thinking realloc frees memory without resizing
• Assuming realloc always allocates new memory without preserving data
• Confusing realloc with memcpy or free

2. Which of the following is the correct syntax to resize a memory block pointed by ptr to hold 50 integers using realloc?

easy

A. ptr = realloc(ptr, 50 * sizeof(int));

B. ptr = realloc(sizeof(int), 50 * ptr);

C. ptr = realloc(50, ptr * sizeof(int));

D. ptr = realloc(ptr, 50);

Solution

1. Step 1: Understand realloc parameters

   realloc takes a pointer and the new size in bytes. To hold 50 integers, size must be 50 times size of int.

2. Step 2: Check each option's correctness

   ptr = realloc(ptr, 50 * sizeof(int)); correctly multiplies 50 by sizeof(int). Others misuse parameters or sizes.

3. Final Answer:

   ptr = realloc(ptr, 50 * sizeof(int)); -> Option A

4. Quick Check:

   Size in bytes = count * sizeof(type) [OK]

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

Common Mistakes:

• Passing count instead of bytes as size
• Swapping parameters in realloc
• Forgetting sizeof(int) when resizing

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

int *arr = malloc(3 * sizeof(int));
arr[0] = 1; arr[1] = 2; arr[2] = 3;
arr = realloc(arr, 5 * sizeof(int));
arr[3] = 4; arr[4] = 5;
for(int i = 0; i < 5; i++) printf("%d ", arr[i]);
free(arr);

medium

A. 1 2 3 0 0

B. 1 2 3 4 5

C. Garbage values after 3 elements

D. Runtime error due to invalid access

Solution

1. Step 1: Analyze memory allocation and initialization

   Initially, 3 integers allocated and set to 1, 2, 3. Then resized to hold 5 integers.

2. Step 2: Assign new values and print

   After realloc, elements 3 and 4 are assigned 4 and 5. Printing all 5 elements outputs 1 2 3 4 5.

3. Final Answer:

   1 2 3 4 5 -> Option B

4. Quick Check:

   realloc preserves old data and new elements assigned [OK]

Hint: realloc keeps old data; new elements must be assigned [OK]

Common Mistakes:

• Assuming new elements are zeroed automatically
• Expecting garbage values without assignment
• Thinking realloc frees old data immediately

4. Identify the error in this code snippet:

int *ptr = malloc(10 * sizeof(int));
ptr = realloc(ptr, 20 * sizeof(int));
if (ptr == NULL) {
    printf("Memory allocation failed\n");
    free(ptr);
}

medium

A. Calling free(ptr) after ptr is NULL does not free the original memory block.

B. Missing check for malloc failure before realloc.

C. Incorrect size calculation in realloc.

D. No error; code is correct.

Solution

1. Step 1: Understand realloc return and NULL check

   If realloc returns NULL, original pointer is lost if not saved separately, and ptr becomes NULL.

2. Step 2: Analyze free(ptr) after NULL assignment

   Calling free(ptr) after ptr is NULL does not free the original memory block, leading to memory leak.

3. Final Answer:

   Calling free(ptr) after ptr is NULL does not free the original memory block. -> Option A

4. Quick Check:

   Check realloc result before overwriting pointer [OK]

Hint: Save realloc result before overwriting pointer [OK]

Common Mistakes:

• Not checking realloc return before assignment
• Freeing NULL pointer thinking it frees old memory
• Ignoring malloc failure before realloc

5. You have a dynamic array of integers allocated with malloc. You want to safely double its size using realloc without losing data or causing memory leaks. Which approach is correct?

hard

A. ptr = malloc(2 * current_size); memcpy(ptr, old_ptr, current_size); free(old_ptr);

B. ptr = realloc(ptr, 2 * current_size); // directly assign realloc result

C. free(ptr); ptr = malloc(2 * current_size); // allocate new memory after freeing

D. int *temp = realloc(ptr, 2 * current_size); if (temp) ptr = temp; else handle error;

Solution

1. Step 1: Understand safe realloc usage

   Directly assigning realloc result to original pointer risks losing original memory if realloc fails.

2. Step 2: Use temporary pointer to check realloc success

   Assign realloc to temp pointer, check if not NULL, then update original pointer. Else handle error safely.

3. Final Answer:

   int *temp = realloc(ptr, 2 * current_size); if (temp) ptr = temp; else handle error; -> Option D

4. Quick Check:

   Use temp pointer to avoid memory leaks on realloc failure [OK]

Hint: Use temp pointer for realloc to avoid losing original memory [OK]

Common Mistakes:

• Overwriting pointer before checking realloc result
• Freeing pointer before realloc causing data loss
• Not handling realloc failure properly