C Programming - Beginner to Brilliance / Pointers in C

Dynamic Memory Allocation

🪄 What is Dynamic Memory Allocation?

Dynamic memory allocation means allocating memory during program execution (runtime) instead of compile-time.

Unlike static memory (like arrays), where you must know the size ahead of time, dynamic memory lets you request memory when needed — and free it later.

🎯 Why Use Dynamic Memory Allocation?

Static Memory (int arr[100];)

Dynamic Memory (malloc)

Fixed size at compile-time

Flexible size at runtime

May waste memory

Efficient usage

Stack allocation

Heap allocation

Limited size

Much larger space

🧰 Functions Used (All from <stdlib.h>)

Function

Description

malloc()

Allocates memory block

calloc()

Allocates and initializes memory

realloc()

Resizes previously allocated memory

free()

Frees previously allocated memory

📦 malloc() – Memory Allocation

📌 Purpose:

Allocates a specified number of bytes in memory and returns a void pointer to the first byte of the allocated space.

💡 Characteristics:

  • Memory is uninitialized (contains garbage values).

  • Returns NULL if memory allocation fails.

🧪 Syntax:

ptr = (cast_type *) malloc(size_in_bytes);

✅ Example:

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

int main() {
    int *ptr = (int *)malloc(sizeof(int) * 5);
    
    // Checking if failed or pass
    if (ptr == NULL) {
        printf("Allocation Failed");
        exit(0);
    }
    
    // Populate the array
    for (int i = 0; i < 5; i++)
        ptr[i] = i + 1;
        
    // Print the array
    for (int i = 0; i < 5; i++)
        printf("%d ", ptr[i]);
    return 0;
}

📝 sizeof(int) is used to calculate size in bytes, ensures portability.

⚠️ Important:

  • Always check if the returned pointer is NULL.

  • Cast is optional in C but required in C++.

📦 calloc() – Contiguous Allocation

📌 Purpose:

Allocates memory for an array of elements and initializes all bytes to zero.

💡 Characteristics:

  • Useful when you want a clean memory block.

  • Slower than malloc() because of the initialization step.

🧪 Syntax:

ptr = (cast_type *) calloc(num_elements, size_of_each);

✅ Example:

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

int main() {
    int *ptr = (int *)calloc(5, sizeof(int));
    
    // Checking if failed or pass
    if (ptr == NULL) {
        printf("Allocation Failed");
        exit(0);
    }
    
    // No need to populate as already
    // initialized to 0
        
    // Print the array
    for (int i = 0; i < 5; i++)
        printf("%d ", ptr[i]);
    return 0;
}

🔄 realloc() – Reallocation of Memory

📌 Purpose:

Changes the size of a previously allocated memory block (malloc or calloc) without losing existing data (if possible).

💡 Characteristics:

  • Expands or shrinks the memory block.

  • May move memory to a new location.

  • If it fails, it returns NULL without freeing the original block.

🧪 Syntax:

ptr = realloc(ptr, new_size);

✅ Example:

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

int main() {
    int *ptr = (int *)malloc(5 * sizeof(int));

    // Resize the memory block to hold 10 integers
    ptr = (int *)realloc(ptr, 10 * sizeof(int));
    
    // Check for allocation failure
    if (ptr == NULL) {
        printf("Memory Reallocation Failed");
        exit(0);
    }

    return 0;
}

❌ free() – Free Allocated Memory

📌 Purpose:

Releases dynamically allocated memory back to the system.

💡 Characteristics:

  • Helps prevent memory leaks.

  • Once freed, accessing the pointer is undefined behavior.

🧪 Syntax:

free(ptr);

✅ Example:

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

int main() {
    int *ptr = (int *)calloc(sizeof(int), 5);
    
    // Do some operations.....
    for (int i = 0; i < 5; i++)
        printf("%d ", ptr[i]);
        
    // Free the memory after completing
    // operations
    free(ptr);
    
    return 0;
}

After calling free(ptr), the pointer ptr becomes a dangling pointer unless set to NULL.

💡 Memory Layout in C (Stack vs Heap)

  • Static memory (like int arr[10]) goes on stack

  • Dynamic memory (like malloc) is allocated on heap

⚠️ Common Mistakes in DMA

Mistake

Why it’s bad

Forgetting free()

Leads to memory leak

Using memory after free()

Undefined behavior (dangling pointer)

Not checking malloc() return value

Can crash on NULL

Incorrect size calculation

May lead to buffer overflows

🔐 Best Practices

✅ Always check if allocation was successful

✅ Use sizeof instead of hardcoding

✅ Always free() when done

✅ Set pointer to NULL after freeing

✅ Avoid memory leaks by keeping track of all allocations

🚀 Real-Life Applications

  • 🌲 Dynamic Data Structures: Linked Lists, Trees, Graphs

  • 📦 Memory-efficient storage in large programs

  • 🎮 Game development and resource loading

  • 💾 Operating systems and embedded systems