1. Why Use Dynamic Memory Allocation?

• Flexibility: Allows allocation of memory when the exact amount required isn't known at compile time.
• Scalability: Useful for managing data structures like linked lists, trees, or arrays that can grow or shrink.

2. Key Functions for Dynamic Memory Allocation:

• malloc(size_t size):

  • Allocates size bytes of uninitialized memory.
  • Returns a pointer to the beginning of the block.
  • If allocation fails, it returns NULL.

  int *ptr = (int*)malloc(10 * sizeof(int));  // Allocates memory for 10 integers
  
  

• calloc(size_t num, size_t size):

  • Allocates memory for an array of num elements, each of size bytes, and initializes all bytes to zero.
  • Returns a pointer to the allocated memory.

  int *ptr = (int*)calloc(10, sizeof(int));  // Allocates and initializes memory for 10 integers
  
  

• realloc(void *ptr, size_t size):

  • Resizes the memory block pointed to by ptr to size bytes.
  • Can expand or shrink the existing block. If expanded, the new memory may not be initialized.
  • Returns a pointer to the new block, which might be at a different memory location.

  ptr = (int*)realloc(ptr, 20 * sizeof(int));  // Resizes the memory block to hold 20 integers
  
  

• free(void *ptr):

  • Deallocates the memory previously allocated by malloc, calloc, or realloc.
  • Does not change the pointer value, so it’s good practice to set the pointer to NULL after freeing.

  free(ptr);  // Frees the allocated memory
  ptr = NULL;  // Avoids dangling pointers
  
  

3. Best Practices:

• Check for NULL: Always check if the returned pointer is NULL to avoid dereferencing a null pointer.
• Avoid Memory Leaks: Ensure every allocated memory block is eventually freed.
• Avoid Dangling Pointers: After freeing memory, set the pointer to NULL to avoid accidental access.
• Use sizeof: When allocating memory, use sizeof to ensure the correct size is allocated, accounting for the data type.

4. Common Issues:

• Memory Leaks: Occur when allocated memory is not freed, leading to wasted memory.
• Dangling Pointers: Occur when accessing memory that has already been freed.
• Double Free: Occurs when attempting to free the same memory block twice, leading to undefined behavior.

5. Applications:

• Dynamic Arrays: Use malloc or realloc to manage arrays that need to change size during runtime.
• Linked Lists: Allocate memory for each node dynamically.