🧠 17. Dynamic Memory Allocation

17.1 What Is Dynamic Memory Allocation?

Dynamic memory allocation lets a C program request storage while the program is running. This is useful when the required amount of memory is not known when the source code is written.

Fixed-size storage

Use ordinary variables and fixed-size arrays when the required storage is known in advance.

Dynamic storage

Request storage at runtime when the program discovers how much data it needs.

Runtime size → request memory → check result → use it → resize if needed → free it

17.2 Why Do We Need Dynamic Memory?

The number of elements may be known only after input is read.
A program may need storage that grows or shrinks during execution.
Large or variable data structures can be created only when required.
Dynamic storage is fundamental to linked lists, trees, dynamic arrays and many real programs.

Think like a programmer: If the user enters n, a fixed array such as int a[1000] may reserve more space than necessary. Dynamic allocation can request storage for exactly the required number of elements.

17.3 Automatic Arrays vs Dynamic Allocation

Ordinary / Automatic Storage	Dynamic Storage
Size is usually determined by the declaration.	Size is requested during execution.
Lifetime is managed automatically for automatic objects.	Programmer controls the allocation and release.
Example: `int a[10];`	Example: `int a = malloc(10 sizeof *a);`
No `free()` is required for an ordinary automatic array.	The allocated block must eventually be released with `free()`.

17.4 Stack and Heap — A Practical Mental Model

Automatic local objects are commonly associated with stack storage, while memory returned by malloc(), calloc() and realloc() comes from dynamically allocated storage, commonly called the heap.

Automatic/local objects

↓

Stack-oriented storage

──────────────

Dynamic allocations

↓

Heap / dynamic storage

Important: These names describe a common implementation. The C rules that matter here are when an object begins to exist, when it stops existing, and who is responsible for releasing allocated storage.

17.5 malloc() — Request a Block of Bytes

malloc() allocates a block of memory containing the requested number of bytes. Its contents are indeterminate; the function does not initialize the allocated bytes for you.

#include <stdlib.h>

int *p = malloc(5 * sizeof *p);

Best habit: Prefer sizeof *p when calculating the size of one pointed-to object. It keeps the expression tied to the pointer’s declared type. Also check the element count and any multiplication used to form the byte count.

17.6 The malloc() Lifecycle

1. Declare pointer
int *p;

↓

2. Allocate
p = malloc(n * sizeof *p);

↓

3. Check
if (p == NULL)

↓

4. Use
p[i]

↓

5. Release
free(p);

17.7 Basic malloc() Example with a Result Check

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

int main(void)
{
    int n;
    scanf("%d", &n);

    int *a = malloc((size_t)n * sizeof *a);
    if (a == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        a[i] = i + 1;

    for (int i = 0; i < n; i++)
        printf("%d ", a[i]);

    free(a);
    return 0;
}

17.8 malloc() Does Not Initialize Your Data

This example assumes that n was read successfully, is positive, and gives a byte count that fits size_t. A program accepting unrestricted input must check those conditions before allocating. After allocation, assign each element before reading it; malloc does not initialize the data. Section 17.32 shows a size-overflow check.

Do not assume: malloc() means “give me an array filled with zero.” It means “give me a block of at least this many bytes.”

17.9 calloc() — Allocate and Zero-Initialize

calloc(count, size) allocates space for an array of count objects, each of size bytes, and initializes the allocated bytes to zero.

int *a = calloc(5, sizeof *a);

For an int array, zeroed bytes give initial values of 0. This is a byte-initialization rule: do not assume that all-bits-zero is the correct representation of every pointer or floating-point value on every C implementation.

17.10 malloc() vs calloc()

Function	Arguments	Initialization	Typical use
`malloc(bytes)`	Total bytes	Allocated bytes are not initialized	When you will assign values yourself
`calloc(count, size)`	Number × size	Allocated bytes are initialized to zero	When zero-initialized storage is useful

17.11 realloc() — Resize an Existing Allocation

realloc() requests a new size for an existing allocation. On success, use the returned pointer for the resized block. Stop using old pointer copies, including pointers to elements in the old block, even if the allocation appears to remain at the same address.

int *tmp = realloc(a, new_count * sizeof *a);

Key idea: Never assume the address stays the same after realloc().

17.12 Why a Temporary Pointer Matters

int *tmp = realloc(a, new_count * sizeof *a);

if (tmp != NULL) {
    a = tmp;
} else {
    /* a is still valid here */
}

Assigning realloc() directly to the only pointer can overwrite it with NULL on failure. For a nonzero requested size, keep the original pointer until you know the resize succeeded. Only then assign the temporary result to it.

17.13 realloc() — What Can Change?

The allocation may grow in place.
The allocation may move to a new location.
Existing contents are preserved up to the smaller of the old and new sizes.
When the block grows, assign values to the added elements before reading them. realloc does not zero that new part.
If a nonzero resize request fails, the original block remains allocated. Decide whether to continue with it or release it. Avoid using realloc(p, 0) as a shortcut for free: zero-size behavior differs across C versions and implementations.

17.14 free() — Release the Allocation

free(ptr) ends the lifetime of the allocated block. Release a live allocation using its starting pointer, not an interior pointer such as p + 1. Do not free an automatic array. free(NULL) is allowed and does nothing.

free(p);
p = NULL;

Good habit: Setting a pointer to NULL after free helps prevent reuse through that variable. It does not update other pointers that referred to the same block; those copies must not be used either.

17.15 What Does NULL Mean Here?

If an allocation function returns NULL for a positive-size request, no usable block was returned. Handle that result before indexing or dereferencing the pointer. Keep zero-element requests separate from this normal allocation path.

int *p = malloc(n * sizeof *p);

if (p == NULL) {
    printf("Allocation failed\n");
    return 1;
}

17.16 Dynamic Arrays

A pointer returned by an allocation function can be indexed using normal array notation.

int *a = malloc(n * sizeof *a);

if (a != NULL) {
    a[0] = 10;
    a[1] = 20;
}

free(a);

The expression a[i] is equivalent to *(a + i). If n elements were allocated, valid indexes are 0 through n - 1. The pointer itself does not store n, so keep the count separately.

17.17 Dynamic Array Representation

int *a → ┌─────┬─────┬─────┬─────┐

│ 10 │ 20 │ 30 │ 40 │

└─────┴─────┴─────┴─────┘

0 1 2 3

The pointer variable and allocated block are different objects. Assigning the pointer to another pointer copies the address; it does not duplicate the elements.

17.18 Dynamically Allocated Strings

Strings are character arrays ending in '\0'. Dynamic allocation therefore needs room for the terminator.

const char *source = "CodeBhavya";
size_t n = strlen(source) + 1;
char *copy = malloc(n);

if (copy != NULL) {
    strcpy(copy, source);
    printf("%s\n", copy);
    free(copy);
}

When using string functions, include <string.h> and make sure the destination has enough capacity.

17.19 Dynamic Structures

struct Student {
    int roll;
    float marks;
};

struct Student *s = malloc(sizeof *s);

if (s != NULL) {
    s->roll = 101;
    s->marks = 86.5f;
    free(s);
}

Use -> when accessing a structure through a pointer.

17.20 Dynamic Array of Structures

struct Student *students =
    malloc(n * sizeof *students);

if (students != NULL) {
    students[0].roll = 101;
    students[0].marks = 86.5f;
}

free(students);

This pattern is useful for runtime-sized collections of records.

17.21 Dynamic 2D Data — Choose a Representation

Choose how the rows will be stored. One contiguous block needs one release and uses an index such as r * cols + c. Separate row allocations need a row-pointer array and a cleanup step for every allocated row.

int *matrix = malloc(rows * cols * sizeof *matrix);

if (matrix != NULL) {
    matrix[r * cols + c] = 42;
}

free(matrix);

Contiguous block

One allocation; access with r * cols + c.

Array of pointers

Each row can have its own length. If allocation fails partway through, release the rows already allocated before releasing the pointer array.

17.22 Allocation Size — Use sizeof Correctly

int *a = malloc(n * sizeof *a);
double *b = malloc(n * sizeof *b);
struct Student *s = malloc(n * sizeof *s);

This avoids hard-coding type sizes. For byte-count calculations involving an object count, use an appropriate unsigned size type such as size_t.

17.23 Allocation Failure Is Also a Program State

Allocation can fail even when the calculation is valid. Check the result, then decide how the program should respond. Do not use a failed result as an array.

Placement point: Interviewers often ask, “What happens when malloc fails?” The correct direction is: it can return NULL; report the failure, release any other storage already owned by this task, and return or choose another valid action.

17.24 Memory Leak

A memory leak occurs when dynamically allocated memory is no longer reachable by the program and therefore cannot be released.

int *p = malloc(100 * sizeof *p);

/* if p is overwritten or lost without free(p),
   the allocation can leak */

Leak ≠ unused variable. In the example, assigning NULL loses the only pointer to an allocated block without freeing it. Setting a pointer to NULL is not a substitute for free.

17.25 Dangling Pointer

A dangling pointer is a pointer that refers to storage whose lifetime has ended.

int *p = malloc(sizeof *p);
if (p != NULL) {
    *p = 25;
    free(p);
    p = NULL;
}

The important rule is not to dereference the old pointer after free().

17.26 Double Free

Releasing the same live allocation twice has undefined behavior. This can happen when two pointers share a block and each is treated as its owner. Decide which part of the program will release it.

free(p);
p = NULL;
/* Do not free the same allocation again. */

17.27 Use-After-Free

Use-after-free means trying to read or write an object after its allocation has been released. A second pointer to the block does not keep it alive.

free(p);
/* *p = 10;  // invalid */

Lifetime rule: Keep allocated storage alive until its final valid use. After releasing it, stop using all pointers that referred to that storage.

17.28 The Complete Dynamic Memory Workflow

Need runtime storage?

↓

Calculate size safely
n * sizeof *p

↓

Allocate
malloc / calloc

↓

Check result
p != NULL

↓

Initialize and use

↓

Need more/less space?
realloc with a temporary pointer

↓

Finish
free(p)

17.29 malloc(), calloc(), realloc(), free() — Quick Comparison

Function	Purpose	Important point
`malloc()`	Allocate a byte block	Contents are not initialized
`calloc()`	Allocate an array of objects	Allocated bytes are zero-initialized
`realloc()`	Resize an allocation	Block may move; use a temporary pointer
`free()`	Release an allocation	Do not access the block afterward

17.30 Common Dynamic Memory Mistakes

❌ No NULL check

Dereferencing a failed allocation is invalid.

❌ Wrong size

Allocate enough bytes for every object, using sizeof.

❌ Lost pointer

Overwriting the only pointer can create a memory leak.

❌ Unsafe realloc

Use a temporary pointer when the old allocation must be preserved on failure.

❌ Use-after-free

Never read or write through a pointer to released storage.

❌ Double free

Release each allocation only once.

17.31 Dynamic Memory Problem-Solving Method

Determine how many objects are required.
Calculate the required byte count.
Allocate with malloc() or calloc().
Check for NULL.
Initialize before reading values.
Stay within the allocated bounds.
Use realloc() carefully if the size changes.
Release every successful allocation exactly once.

CodeBhavya Rule: Dynamic memory is not just about malloc(). Always think in three questions: How much memory? Who owns it? When is its lifetime finished?

17.32 Allocation-Size Overflow and Robust Dynamic Arrays

Before forming count * sizeof *p, check whether count exceeds SIZE_MAX / sizeof *p. Otherwise, an oversized multiplication can wrap and request a block smaller than the program expects. A successful malloc alone does not prove the size calculation was correct.

Complete C program:

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

int main(void)
{
    size_t count = 4;
    if (count > SIZE_MAX / sizeof(int)) {
        fputs("Size overflow\n", stderr);
        return 1;
    }
    int *items = malloc(count * sizeof *items);
    if (items == NULL) return 1;
    for (size_t i = 0; i < count; ++i) items[i] = (int)i * 2;
    printf("Last = %d\n", items[count - 1]);
    free(items);
    return 0;
}

Expected output:

Last = 6

Step-by-step explanation:

SIZE_MAX is the largest size_t value.
The division check rejects counts that would overflow the byte calculation.
The successfully allocated array is initialized and freed.

Remember: For a nonzero resize, preserve the old pointer until realloc succeeds. On success, replace it with the returned pointer and stop using old aliases. If the requested element count is zero, handle release explicitly with free.

17.33 Quick Revision

📌 malloc() → Allocates memory

📌 calloc() → Allocates and zero-initializes bytes

📌 realloc() → Resizes an allocation

📌 free() → Releases memory

📌 NULL → Indicates a null pointer

📌 Heap → Commonly used for dynamic storage

📌 Memory leak → Allocated memory is not released

📌 Dangling pointer → Pointer refers to an object whose lifetime has ended

📌 Use-after-free → Accessing freed memory

📌 sizeof *ptr → Useful for type-safe allocation sizing

INTERACTIVE LEARNING

🎬 Dynamic Memory — Allocation Lifecycle

Follow the complete lifecycle from requesting heap memory to releasing it safely.

PROGRAM TRACING

🔎 Program Tracing — Dynamic Memory Allocation

Trace allocation, initialization, safe resizing with a temporary pointer, and release.

17.34 Quick MCQs

Select an answer first, then click Check Answer. A correct choice becomes green. If the answer is wrong, your choice becomes red and the correct option becomes green. The explanation appears below.

PRACTICE

17.35 🎯 Practice Problems

Practice allocation, arrays, strings, structures, matrices, realloc(), allocation checks, and memory-leak prevention. Use 💻 Solve It Yourself first, open Hint only when needed, and use Show Program after attempting the problem.

📈 Dynamic Memory Allocation Practice Progress

Solved 0 / 20

Completed with Solution 0

Total Score 0 / 400

Completion 0%

A problem counts as Solved when all test cases pass without opening the full solution. Problems completed after viewing the official solution are tracked separately.

1. Allocate One Integer

Problem 1: Allocate memory dynamically for one integer and store a value in it.

Input: One integer.

Output: Print the stored integer.

Official C Program

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

int main()
{
    int value;

    scanf("%d", &value);

    int *p = malloc(sizeof *p);

    if (p == NULL)
        return 1;

    *p = value;

    printf("%d", *p);

    free(p);

    return 0;
}

2. Allocate an Array of N Integers

Problem 2: Dynamically allocate an array of n integers and initialize it with 1 to n.

Input: One positive integer n.

Output: Print the n initialized values.

Official C Program

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

int main()
{
    int n;

    scanf("%d", &n);

    if (n <= 0)
        return 0;

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        arr[i] = i + 1;

    for (int i = 0; i < n; i++)
    {
        if (i > 0)
            printf(" ");

        printf("%d", arr[i]);
    }

    free(arr);

    return 0;
}

3. Sum of a Dynamically Allocated Array

Problem 3: Read n numbers into a dynamically allocated array and find their sum.

Input: n followed by n integers.

Output: Print the sum.

Official C Program

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

int main()
{
    int n;
    long long sum = 0;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
        sum += arr[i];
    }

    printf("%lld", sum);

    free(arr);

    return 0;
}

4. Largest Element in a Dynamic Array

Problem 4: Find the largest element in a dynamically allocated array.

Input: n greater than 0 followed by n integers.

Output: Print the largest value.

Official C Program

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

int main()
{
    int n;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    int maximum = arr[0];

    for (int i = 1; i < n; i++)
    {
        if (arr[i] > maximum)
            maximum = arr[i];
    }

    printf("%d", maximum);

    free(arr);

    return 0;
}

5. Smallest Element in a Dynamic Array

Problem 5: Find the smallest element in a dynamically allocated array.

Input: n greater than 0 followed by n integers.

Output: Print the smallest value.

Official C Program

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

int main()
{
    int n;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    int minimum = arr[0];

    for (int i = 1; i < n; i++)
    {
        if (arr[i] < minimum)
            minimum = arr[i];
    }

    printf("%d", minimum);

    free(arr);

    return 0;
}

6. Reverse a Dynamic Array

Problem 6: Reverse a dynamically allocated array.

Input: n followed by n integers.

Output: Print the reversed array.

Official C Program

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

int main()
{
    int n;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    for (int left = 0, right = n - 1; left < right; left++, right--)
    {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }

    for (int i = 0; i < n; i++)
    {
        if (i > 0)
            printf(" ");

        printf("%d", arr[i]);
    }

    free(arr);

    return 0;
}

7. calloc() Initial Values

Problem 7: Use calloc() to create an array of integers and display its initial values.

Input: One positive integer n.

Output: Print n zero values separated by spaces.

Official C Program

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

int main()
{
    int n;

    scanf("%d", &n);

    int *arr = calloc((size_t)n, sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
    {
        if (i > 0)
            printf(" ");

        printf("%d", arr[i]);
    }

    free(arr);

    return 0;
}

8. Increase Array Size with realloc()

Problem 8: Use realloc() to increase the size of an integer array.

Input: Initial size n, n integers, new size m where m >= n, followed by m-n additional integers.

Output: Print all m values.

Official C Program

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

int main()
{
    int n, m;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    scanf("%d", &m);

    int *temp = realloc(arr, (size_t)m * sizeof *arr);

    if (temp == NULL)
    {
        free(arr);
        return 1;
    }

    arr = temp;

    for (int i = n; i < m; i++)
        scanf("%d", &arr[i]);

    for (int i = 0; i < m; i++)
    {
        if (i > 0)
            printf(" ");

        printf("%d", arr[i]);
    }

    free(arr);

    return 0;
}

9. Reduce Array Size with realloc()

Problem 9: Use realloc() to reduce the size of an array.

Input: Initial size n, n integers, then new size m where 0 < m <= n.

Output: Print the first m values retained in the resized block.

Official C Program

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

int main()
{
    int n, m;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    scanf("%d", &m);

    int *temp = realloc(arr, (size_t)m * sizeof *arr);

    if (temp == NULL)
    {
        free(arr);
        return 1;
    }

    arr = temp;

    for (int i = 0; i < m; i++)
    {
        if (i > 0)
            printf(" ");

        printf("%d", arr[i]);
    }

    free(arr);

    return 0;
}

10. Dynamically Allocate a String

Problem 10: Dynamically allocate memory for a string and store a user-provided string.

Input: One line of text.

Output: Print the dynamically stored string.

Official C Program

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

int main()
{
    char buffer[300];

    fgets(buffer, sizeof(buffer), stdin);
    buffer[strcspn(buffer, "\n")] = '\0';

    char *text = malloc(strlen(buffer) + 1);

    if (text == NULL)
        return 1;

    strcpy(text, buffer);

    printf("%s", text);

    free(text);

    return 0;
}

11. Dynamically Allocate a Structure

Problem 11: Dynamically allocate a structure and access its members.

Input: Student roll number and marks.

Output: Print the stored members.

Official C Program

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

struct Student
{
    int roll;
    float marks;
};

int main()
{
    struct Student *s = malloc(sizeof *s);

    if (s == NULL)
        return 1;

    scanf("%d %f", &s->roll, &s->marks);

    printf("%d %.1f", s->roll, s->marks);

    free(s);

    return 0;
}

12. Dynamic Array of Structures

Problem 12: Dynamically allocate an array of structures.

Input: n followed by n student records: roll and marks.

Output: Print all student records.

Official C Program

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

struct Student
{
    int roll;
    float marks;
};

int main()
{
    int n;

    scanf("%d", &n);

    struct Student *students = malloc((size_t)n * sizeof *students);

    if (students == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d %f", &students[i].roll, &students[i].marks);

    for (int i = 0; i < n; i++)
    {
        if (i > 0)
            printf("\n");

        printf("%d %.1f", students[i].roll, students[i].marks);
    }

    free(students);

    return 0;
}

13. Dynamic 2D Matrix

Problem 13: Create a dynamically allocated 2D matrix.

Input: Rows r, columns c, followed by r*c integers.

Output: Print the matrix.

Official C Program

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

int main()
{
    int r, c;

    scanf("%d %d", &r, &c);

    int **matrix = malloc((size_t)r * sizeof *matrix);

    if (matrix == NULL)
        return 1;

    for (int i = 0; i < r; i++)
    {
        matrix[i] = malloc((size_t)c * sizeof *matrix[i]);

        if (matrix[i] == NULL)
        {
            for (int j = 0; j < i; j++)
                free(matrix[j]);

            free(matrix);
            return 1;
        }
    }

    for (int i = 0; i < r; i++)
        for (int j = 0; j < c; j++)
            scanf("%d", &matrix[i][j]);

    for (int i = 0; i < r; i++)
    {
        for (int j = 0; j < c; j++)
        {
            if (j > 0)
                printf(" ");

            printf("%d", matrix[i][j]);
        }

        if (i < r - 1)
            printf("\n");
    }

    for (int i = 0; i < r; i++)
        free(matrix[i]);

    free(matrix);

    return 0;
}

14. Add Two Dynamic Matrices

Problem 14: Add two dynamically allocated matrices.

Input: Rows r, columns c, first matrix values, then second matrix values.

Output: Print the sum matrix.

Official C Program

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

int main()
{
    int r, c;

    scanf("%d %d", &r, &c);

    size_t count = (size_t)r * (size_t)c;

    int *a = malloc(count * sizeof *a);
    int *b = malloc(count * sizeof *b);
    int *sum = malloc(count * sizeof *sum);

    if (a == NULL || b == NULL || sum == NULL)
    {
        free(a);
        free(b);
        free(sum);
        return 1;
    }

    for (size_t i = 0; i < count; i++)
        scanf("%d", &a[i]);

    for (size_t i = 0; i < count; i++)
        scanf("%d", &b[i]);

    for (size_t i = 0; i < count; i++)
        sum[i] = a[i] + b[i];

    for (int i = 0; i < r; i++)
    {
        for (int j = 0; j < c; j++)
        {
            if (j > 0)
                printf(" ");

            printf("%d", sum[(size_t)i * c + j]);
        }

        if (i < r - 1)
            printf("\n");
    }

    free(a);
    free(b);
    free(sum);

    return 0;
}

15. Transpose a Dynamic Matrix

Problem 15: Find the transpose of a dynamically allocated matrix.

Input: Rows r, columns c, followed by r*c integers.

Output: Print the transposed matrix with c rows and r columns.

Official C Program

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

int main()
{
    int r, c;

    scanf("%d %d", &r, &c);

    size_t count = (size_t)r * (size_t)c;

    int *matrix = malloc(count * sizeof *matrix);

    if (matrix == NULL)
        return 1;

    for (size_t i = 0; i < count; i++)
        scanf("%d", &matrix[i]);

    for (int j = 0; j < c; j++)
    {
        for (int i = 0; i < r; i++)
        {
            if (i > 0)
                printf(" ");

            printf("%d", matrix[(size_t)i * c + j]);
        }

        if (j < c - 1)
            printf("\n");
    }

    free(matrix);

    return 0;
}

16. malloc() vs calloc()

Problem 16: Demonstrate the difference between malloc() and calloc() without reading uninitialized malloc memory.

Input: One positive integer n.

Output: Print "malloc needs initialization" and whether all calloc values begin as zero.

Official C Program

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

int main()
{
    int n;

    scanf("%d", &n);

    int *a = malloc((size_t)n * sizeof *a);
    int *b = calloc((size_t)n, sizeof *b);

    if (a == NULL || b == NULL)
    {
        free(a);
        free(b);
        return 1;
    }

    int allZero = 1;

    for (int i = 0; i < n; i++)
    {
        a[i] = i + 1;

        if (b[i] != 0)
            allZero = 0;
    }

    printf("malloc needs initialization\n");
    printf("calloc zero = %s", allZero ? "Yes" : "No");

    free(a);
    free(b);

    return 0;
}

17. Safely Handle Allocation Failure

Problem 17: Write a program that validates the requested array size and checks malloc() before use.

Input: One integer n.

Output: Print "Allocated" for an accepted request or "Request Rejected" for an unsafe request.

Official C Program

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

int main()
{
    long long n;

    scanf("%lld", &n);

    if (n <= 0 || n > 1000000)
    {
        printf("Request Rejected");
        return 0;
    }

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
    {
        printf("Allocation Failed");
        return 0;
    }

    printf("Allocated");

    free(arr);

    return 0;
}

18. Safe realloc() with a Temporary Pointer

Problem 18: Demonstrate realloc() using a temporary pointer so the original allocation is preserved if resizing fails.

Input: Initial size n, n integers, and new size m where m >= n, followed by new values.

Output: Print the resized array.

Official C Program

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

int main()
{
    int n, m;

    scanf("%d", &n);

    int *arr = malloc((size_t)n * sizeof *arr);

    if (arr == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    scanf("%d", &m);

    int *temp = realloc(arr, (size_t)m * sizeof *arr);

    if (temp == NULL)
    {
        free(arr);
        return 1;
    }

    arr = temp;

    for (int i = n; i < m; i++)
        scanf("%d", &arr[i]);

    for (int i = 0; i < m; i++)
    {
        if (i > 0)
            printf(" ");

        printf("%d", arr[i]);
    }

    free(arr);

    return 0;
}

19. Memory Leak and Prevention

Problem 19: Demonstrate how a memory leak could occur and show the correct prevention pattern.

Input: One integer.

Output: Print the stored value and "Memory Released".

Official C Program

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

int main()
{
    int value;

    scanf("%d", &value);

    int *p = malloc(sizeof *p);

    if (p == NULL)
        return 1;

    *p = value;

    printf("%d\n", *p);

    /*
       If p were overwritten here before free(p),
       the allocation could become unreachable and leak.
    */
    free(p);
    p = NULL;

    printf("Memory Released");

    return 0;
}

20. Dynamic Student Record Management

Problem 20: Create a dynamic Student Record Management System using an array of structures.

Input: n student records (roll, one-word name, marks), then a target roll number.

Output: Print all records, then print the matching student's name and marks or Not Found.

Official C Program

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

struct Student
{
    int roll;
    char name[30];
    float marks;
};

int main()
{
    int n, target;

    scanf("%d", &n);

    struct Student *students = malloc((size_t)n * sizeof *students);

    if (students == NULL)
        return 1;

    for (int i = 0; i < n; i++)
        scanf("%d %29s %f", &students[i].roll, students[i].name, &students[i].marks);

    for (int i = 0; i < n; i++)
        printf("%d %s %.1f\n", students[i].roll, students[i].name, students[i].marks);

    scanf("%d", &target);

    for (int i = 0; i < n; i++)
    {
        if (students[i].roll == target)
        {
            printf("Found: %s %.1f", students[i].name, students[i].marks);
            free(students);
            return 0;
        }
    }

    printf("Not Found");

    free(students);

    return 0;
}

17.36 Key Takeaway

🎯 Remember:

malloc() → Allocate memory

calloc() → Allocate + zero-initialize bytes

realloc() → Resize allocation

free() → Release memory

NULL → Check allocation failure

Heap → Common area for dynamic storage

Memory Leak → Allocated memory not released

Dangling Pointer → Pointer to expired/freed object

Use-After-Free → Accessing freed memory

INTERVIEW PREPARATION

🎤 Dynamic Memory Allocation — Interview Questions

1. What is the difference between malloc() and calloc()?

2. Why should allocation results be checked against NULL?

3. Why is using a temporary pointer with realloc() safer?

4. What is a memory leak?

5. What is a dangling pointer?

6. What is a double free?

7. Does free() set the pointer variable to NULL automatically?

8. Why is sizeof *ptr often preferred in allocation expressions?

PLACEMENT TIPS

💡 Dynamic Memory Allocation — Placement Tips

After every important allocation, check whether the returned pointer is NULL before dereferencing it.
Prefer allocation expressions such as malloc(n * sizeof *arr) so the size stays tied to the pointed-to type.
With realloc(), use a temporary pointer and update the original pointer only after success.
Match every successful dynamic allocation with a clear ownership plan for exactly one eventual free().
After free(), do not read or write through that pointer. Setting an owning pointer to NULL can reduce accidental reuse.
In matrix and multi-allocation problems, if a later allocation fails, free every earlier successful allocation before returning.

EXTRA PRACTICE

✍️ Dynamic Memory Allocation — Extra Practice Questions

Dynamically allocate an integer array and remove all duplicate values into a new resized array.
Create a dynamic string array where each student name receives only the memory it needs.
Allocate a jagged 2D array where each row has a different number of columns.
Build a dynamic matrix multiplication program with complete allocation-failure cleanup.
Implement a growing integer list that doubles its capacity with realloc() when full.
Create a dynamic structure containing its own dynamically allocated string member and write a cleanup function for it.

🧠 17. Dynamic Memory Allocation

17.1 What Is Dynamic Memory Allocation?

Fixed-size storage

Dynamic storage

17.2 Why Do We Need Dynamic Memory?

17.3 Automatic Arrays vs Dynamic Allocation

17.4 Stack and Heap — A Practical Mental Model

17.5 malloc() — Request a Block of Bytes

17.6 The malloc() Lifecycle

17.7 Basic malloc() Example with a Result Check

17.8 malloc() Does Not Initialize Your Data

17.9 calloc() — Allocate and Zero-Initialize

17.10 malloc() vs calloc()

17.11 realloc() — Resize an Existing Allocation

17.12 Why a Temporary Pointer Matters

17.13 realloc() — What Can Change?

17.14 free() — Release the Allocation

17.15 What Does NULL Mean Here?

17.16 Dynamic Arrays

17.17 Dynamic Array Representation

17.18 Dynamically Allocated Strings

17.19 Dynamic Structures

17.20 Dynamic Array of Structures

17.21 Dynamic 2D Data — Choose a Representation

Contiguous block

Array of pointers

17.22 Allocation Size — Use sizeof Correctly

17.23 Allocation Failure Is Also a Program State

17.24 Memory Leak

17.25 Dangling Pointer

17.26 Double Free

17.27 Use-After-Free

17.28 The Complete Dynamic Memory Workflow

17.29 malloc(), calloc(), realloc(), free() — Quick Comparison

17.30 Common Dynamic Memory Mistakes

❌ No NULL check

❌ Wrong size

❌ Lost pointer

❌ Unsafe realloc

❌ Use-after-free

❌ Double free

17.31 Dynamic Memory Problem-Solving Method

17.32 Allocation-Size Overflow and Robust Dynamic Arrays

17.33 Quick Revision

🎬 Dynamic Memory — Allocation Lifecycle

🎬 Dynamic Memory Lifecycle Visualizer

🔎 Program Tracing — Dynamic Memory Allocation

17.34 Quick MCQs

17.35 🎯 Practice Problems

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output

Test Cases

C Code Editor

Sample Input

Program Output