When a block of memory is no longer needed, it should be deallocated, also known as “freeing” the memory.
Dynamic memory remains reserved until deallocated or until the program terminates.
Upon deallocation, the memory becomes available for use by other programs or can be allocated to another part of the program.
To release memory, employ the free() function.
| free(pointer); |
The pointer parameter refers to the address of the memory that needs to be deallocated.
| int *ptr; ptr = malloc(sizeof(*ptr)); free(ptr); |
|
Setting a pointer to NULL after freeing memory is advised as a good practice to prevent unintended further use. This helps mitigate the risk of accidentally accessing invalid memory locations. Continuing to use memory after it has been freed can result in the corruption of data from other programs or even within another section of your own program. |
Could you provide an example with proper error checking and memory deallocation included?
| int *ptr; ptr = malloc(sizeof(*ptr)); // Allocate memory for one integer // If memory cannot be allocated, print a message and end the main() function if (ptr == NULL) { printf(“Unable to allocate memory”); return 1; } // Set the value of the integer // Print the integer value // Free allocated memory // Set the pointer to NULL to prevent it from being accidentally used |
When dynamic memory is allocated but not freed, it results in a memory leak.
In scenarios where a memory leak occurs within a loop or a frequently called function, it can lead to excessive memory consumption, consequently slowing down the computer.
The risk of a memory leak arises when a pointer to dynamic memory is misplaced before its proper deallocation. Such occurrences can be inadvertent, underscoring the importance of attentiveness and meticulous pointer management.
Below are examples illustrating situations where a pointer to dynamic memory may be misplaced.
The pointer is replaced with another value.
| int x = 5; int *ptr; ptr = calloc(2, sizeof(*ptr)); ptr = &x; |
In this scenario, once the pointer is reassigned to point at x, the memory allocated by calloc() becomes unreachable.
The pointer is confined to the scope of a function.
| void myFunction() { int *ptr; ptr = malloc(sizeof(*ptr)); } int main() { |
In this example, memory allocated within the function persists even after the function concludes, yet it becomes inaccessible. To mitigate this issue, one approach is to deallocate the memory before the function’s termination.
The pointer becomes misplaced when reallocation fails.
| int* ptr; ptr = malloc(sizeof(*ptr)); ptr = realloc(ptr, 2*sizeof(*ptr)); |
If realloc() fails to reallocate memory, it returns a pointer to NULL, leaving the original memory reserved.
In this scenario, if realloc() fails, the ptr variable is assigned the NULL pointer, replacing the original memory address and rendering it inaccessible.
In summary, when handling memory in C, adhere to best practices:
