Memory Deallocation

Memory deallocation in C is a crucial aspect of programming, especially when working with dynamically allocated memory. Here's how memory deallocation works in C:

1. Static Memory Allocation: For variables declared at compile-time or statically, memory is automatically allocated and deallocated by the compiler. This includes variables declared globally or with the static keyword inside functions.

2. Dynamic Memory Allocation: Memory allocation using functions like malloc(), calloc(), or realloc() requires manual deallocation using the free() function when the memory is no longer needed. If you fail to deallocate dynamically allocated memory, it can lead to memory leaks, where the program consumes memory unnecessarily.

   // Dynamic memory allocation
   int *ptr = (int *)malloc(sizeof(int));
   // Use ptr
   // When finished, deallocate memory
   free(ptr);

3. Memory Leaks: If you don't free dynamically allocated memory before losing all references to it, the memory will be inaccessible but not released, causing a memory leak. Over time, memory leaks can degrade the performance of the program and lead to crashes due to insufficient memory.

4. Double Free: Attempting to free memory that has already been deallocated is known as a double free and can lead to undefined behavior, including program crashes. It's crucial to ensure that you only free memory once and that you don't attempt to free memory that was never dynamically allocated or has already been freed.

   int *ptr = (int *)malloc(sizeof(int));
   free(ptr);
   free(ptr); // Double free, undefined behavior

5. Dangling Pointers: After deallocating memory, the pointer still points to the same memory location, but the memory is no longer valid. Accessing or manipulating such pointers leads to undefined behavior. To avoid this, it's a good practice to set the pointer to NULL after deallocation.

   int *ptr = (int *)malloc(sizeof(int));
   free(ptr);
   ptr = NULL; // Avoids dangling pointer

In summary, proper memory deallocation in C involves releasing dynamically allocated memory using free() once it's no longer needed, avoiding memory leaks, double frees, and ensuring pointers are not left dangling after deallocation.