How do you free a struct allocated with malloc in C?

In C, when you allocate memory dynamically for a struct using malloc, it's crucial to free that memory once you're done using it to prevent memory leaks. The function used to free dynamically allocated memory is free().

Here's a step-by-step guide on how to free a struct allocated with malloc:

1. Allocate memory using `malloc`:

- First, you'll need to allocate the necessary memory for your struct. The size of the struct must be calculated using the sizeof operator. For example:

#include <stdlib.h>

typedef struct {
int id;
char name;
} Person;

Person myPerson = (Person)malloc(sizeof(Person));
if (myPerson == NULL) {
//Handle memory allocation failure.
return 1;
}

2. Use the allocated memory:

- You would then use the struct for whatever purposes you intend, making sure to copy or allocate memory for the string inside, in case there's any:

myPerson->id = 123;
myPerson->name = (char)malloc(sizeof(char) 20);
if(myPerson->name == NULL) {
free(myPerson); // Free previously allocated memory
return 1;
}
strcpy(myPerson->name, "John Doe");

3. Free the memory using `free()`:

- When you're finished with the struct, it's time to free the memory. The free() function takes a pointer to the allocated memory block as its argument:

free(myPerson->name); //Free allocated char
free(myPerson); //Free struct

- It's crucial to free the memory used by the members of the struct, before freeing the struct itself. In this case name was a pointer allocated with malloc, and needs to be freed first.

4. Best Practices:

- Always check for NULL: After allocating memory with malloc, it is important to check if the returned pointer is NULL. If it is, the allocation failed and you should not proceed to use the pointer. You should then handle memory allocation errors appropriately.

- Free all allocated memory: Make sure that you free all dynamically allocated memory, not just the struct itself. If your struct contains pointers to dynamically allocated memory (like the char name in the example above), you need to free this memory separately before freeing the struct.

- Set pointers to NULL after freeing: After freeing the memory, it's a good practice to set the pointer to NULL to avoid accidental use of the dangling pointer.

- Avoid double frees: Don't call free() on the same pointer twice. Doing so can cause program instability and is considered undefined behavior.

By following these guidelines, you can effectively manage dynamically allocated memory using malloc and free in C and avoid memory leaks.

Learn more about this