C Heap Operations 🎯

Welcome to our deep dive into C Heap Operations! In this comprehensive guide, we'll explore the heap in C, its importance, and how to perform various heap operations. Let's get started! 📝

Understanding the Heap 📝

The heap is a region of memory in C, dynamically allocated during runtime. Unlike the stack, the heap memory is not bounded, allowing it to grow or shrink as required. The heap is primarily used for dynamic memory allocation. 💡 Pro Tip: The heap is ideal for storing data structures that have varying sizes, such as linked lists or trees.

Allocating Memory in the Heap 🎯

To allocate memory in the heap, we use the malloc() function. Let's see an example:

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

int main() {
    int *p;
    int size = 10;

    // Allocate memory for an array of 10 integers
    p = (int *)malloc(size * sizeof(int));
    if (p == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    // Now you can use 'p' as an array of integers
    // ...

    free(p); // Don't forget to free the allocated memory when done!
    return 0;
}

In the example above, we allocate memory for an array of 10 integers using malloc(). If memory allocation is successful, we can access the memory using the pointer p. When we're done using the allocated memory, it's essential to free it using the free() function to avoid memory leaks.

Reallocating Memory in the Heap 🎯

Sometimes, we need to change the size of the memory block already allocated in the heap. To do this, we use the realloc() function. Here's an example:

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

int main() {
    int *p;
    int size = 10;

    // Allocate memory for an array of 10 integers
    p = (int *)malloc(size * sizeof(int));

    // ...

    // Now we need more memory, so let's reallocate
    size *= 2;
    p = (int *)realloc(p, size * sizeof(int));

    // Now 'p' points to a memory block with double the size
    // ...

    free(p); // Don't forget to free the allocated memory when done!
    return 0;
}

In the example above, we initially allocate memory for an array of 10 integers. Later, we need more memory, so we reallocate the memory block using realloc(). The realloc() function adjusts the size of the memory block and returns a new pointer to the adjusted memory block.

Deallocating Memory in the Heap 🎯

When we're done using the memory allocated in the heap, it's crucial to deallocate it using the free() function. This allows the memory to be reused by other parts of the program. Here's an example:

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

int main() {
    int *p;
    int size = 10;

    // Allocate memory for an array of 10 integers
    p = (int *)malloc(size * sizeof(int));

    // ...

    // Now we're done, so let's free the allocated memory
    free(p);

    return 0;
}

In the example above, we allocate memory for an array of 10 integers. Once we're done using the memory, we deallocate it using free().

Happy coding! 🎉