C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Complete guide to free() in C programming — releasing heap memory, dangling pointers, double-free errors, memory leaks, best practices for safe deallocation with practical examples.
Every byte you allocate with malloc(), calloc(), or realloc() must eventually be returned to the system. That's the job of free(). Unlike languages with garbage collectors (Java, Python), C puts the responsibility entirely on you — the programmer.
Failing to free memory causes memory leaks. Freeing memory incorrectly causes crashes and security vulnerabilities. Understanding free() properly is essential for writing robust C programs.
Syntax of free()
c example
void free(void *ptr);| Parameter | Description |
|---|---|
ptr | Pointer to memory previously allocated by malloc/calloc/realloc |
| Return value | None (void) |
How free() Works
| Your data: 10, 20, 30... | USED | |
|---|---|---|
| (available for reuse) | FREE |
After free(), the pointer still holds the old address, but that memory is no longer yours. This creates a dangling pointer.
Basic free() Example
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
// Allocate memory
int *arr = (int *)malloc(5 * sizeof(int));
if (arr == NULL) return 1;
// Use memory
for (int i = 0; i < 5; i++) {
arr[i] = i * 10;
}
printf("Before free: ");
for (int i = 0; i < 5; i++) printf("%d ", arr[i]);
printf("\n");
// Release memory
free(arr);
arr = NULL; // Best practice: prevent dangling pointer
printf("Memory freed successfully.\n");
return 0;
}
Output
Before free: 0 10 20 30 40 Memory freed successfully.
Dangling Pointers — The Silent Killer
A dangling pointer is a pointer that refers to memory that has already been freed:
c example
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr = (int *)malloc(sizeof(int));
*ptr = 42;
printf("Before free: %d\n", *ptr);
free(ptr);
// ptr is now DANGLING — it still points to the freed address
// UNDEFINED BEHAVIOR — might print 42, might crash, might print garbage
// printf("After free: %d\n", *ptr); // DON'T DO THIS!
// SOLUTION: Set to NULL after free
ptr = NULL;
// Now safely check before use
if (ptr != NULL) {
printf("Value: %d\n", *ptr);
} else {
printf("Pointer is NULL — memory was freed.\n");
}
return 0;
}Output
Before free: 42 Pointer is NULL — memory was freed.
Double Free — A Dangerous Bug
Freeing the same memory twice causes undefined behavior — crashes, heap corruption, or security exploits:
c example
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr = (int *)malloc(sizeof(int));
*ptr = 100;
free(ptr); // First free — OK
// free(ptr); // Second free — UNDEFINED BEHAVIOR! (crash/corruption)
// PREVENTION: Set to NULL after free
ptr = NULL;
free(ptr); // free(NULL) is safe — does nothing
printf("No crash because free(NULL) is a no-op.\n");
return 0;
}Output
No crash because free(NULL) is a no-op.
free(NULL) is Always Safe
The C standard guarantees that free(NULL) does nothing. This is why setting pointers to NULL after freeing is so powerful — even if you accidentally call free again, it won't crash.
c example
int *ptr = NULL;
free(ptr); // Perfectly safe — no crash, no errorWhat You Cannot Free
Example
// These will all cause UNDEFINED BEHAVIOR:
int x = 10;
free(&x); // ERROR: stack variable, not from heap
int arr[5];
free(arr); // ERROR: stack array, not from heap
int *p = (int *)malloc(40);
free(p + 2); // ERROR: not the original pointer from malloc
char *str = "hello";
free(str); // ERROR: string literal, not from heap
Memory Leaks — When You Forget to Free
Example
#include <stdio.h>
#include <stdlib.h>
void leaky_function() {
int *data = (int *)malloc(1000 * sizeof(int));
// ... do some work ...
// OOPS: forgot to free(data)!
// When function returns, 'data' pointer is lost
// but the 4000 bytes on the heap remain allocated forever
}
int main() {
// Each call leaks 4000 bytes
for (int i = 0; i < 1000; i++) {
leaky_function();
}
// 4,000,000 bytes leaked!
printf("Program running with leaked memory...\n");
return 0;
}
Output
Program running with leaked memory...
Proper Cleanup Pattern
Example
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char *name;
int *scores;
int num_scores;
} Student;
Student *create_student(const char *name, int n) {
Student *s = (Student *)malloc(sizeof(Student));
if (s == NULL) return NULL;
s->name = (char *)malloc(strlen(name) + 1);
s->scores = (int *)malloc(n * sizeof(int));
s->num_scores = n;
if (s->name == NULL || s->scores == NULL) {
free(s->name); // safe even if NULL
free(s->scores); // safe even if NULL
free(s);
return NULL;
}
strcpy(s->name, name);
return s;
}
void destroy_student(Student *s) {
if (s == NULL) return;
free(s->name); // Free inner allocations first
s->name = NULL;
free(s->scores);
s->scores = NULL;
free(s); // Free the struct last
}
int main() {
Student *s = create_student("Alice", 5);
if (s != NULL) {
printf("Created student: %s\n", s->name);
destroy_student(s);
s = NULL;
printf("Student destroyed cleanly.\n");
}
return 0;
}
Output
Created student: Alice Student destroyed cleanly.
Common free() Mistakes
| Mistake | Consequence | Prevention |
|---|---|---|
| Not freeing at all | Memory leak | Always pair alloc/free |
| Double free | Heap corruption, crash | Set ptr = NULL after free |
| Use after free | Undefined behavior | Set ptr = NULL, check before use |
| Freeing stack memory | Crash | Only free malloc/calloc/realloc results |
| Freeing partial pointer | Crash | Always free the original pointer |
| Freeing in wrong order | Dangling pointers in struct | Free inner members first |
Interview Questions
Q1: What happens if you call free() on a pointer not returned by malloc/calloc/realloc?
This is undefined behavior. It may crash immediately, corrupt the heap silently, or appear to work but cause mysterious bugs later. Only pass pointers from dynamic allocation functions to free().
Q2: Is it safe to call free(NULL)?
Yes. The C standard (C89 and later) guarantees that free(NULL) is a no-op — it does nothing and does not crash. This is why setting freed pointers to NULL is a good practice.
Q3: What is a memory leak and how do you prevent it?
A memory leak occurs when dynamically allocated memory is never freed, usually because the pointer to it is lost (goes out of scope, gets overwritten). Prevent leaks by: (1) always pairing each malloc with a free, (2) using cleanup functions for complex structures, (3) using tools like Valgrind to detect leaks.
Q4: What is a dangling pointer?
A dangling pointer is a pointer that refers to memory that has been freed. Accessing a dangling pointer is undefined behavior. Prevent it by setting pointers to NULL immediately after calling free().
Q5: Why should you free inner members before the outer struct?
If you free the outer struct first, you lose access to the pointers stored inside it (the inner members). Those inner allocations become unreachable — a memory leak. Always free from the inside out.
Summary
free()returns heap memory to the system- Always set pointers to NULL after freeing (
ptr = NULL) free(NULL)is safe and guaranteed to do nothing- Never free stack memory, string literals, or partial pointers
- Never use a pointer after freeing it (dangling pointer)
- Never free the same pointer twice (double-free)
- For nested structures, free inner allocations before outer ones
- Use tools like Valgrind to detect leaks and invalid frees
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for free() in C – Releasing Dynamic Memory.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, dynamic, memory, allocation, free, function
Related C Programming Topics
Continue learning this concept
Dynamic Memory Allocationcalloc() in C – Contiguous Memory AllocationComplete guide to calloc() in C programming — syntax, zero-initialization, difference from malloc, practical examples with output, when to use calloc vs malloc, and common interview questions.Dynamic Memory AllocationDynamic Arrays in C – Runtime-Sized ArraysComplete guide to dynamic arrays in C — creating arrays at runtime, growing arrays with realloc, implementing ArrayList-like behavior, 2D dynamic arrays, and practical examples with output.Dynamic Memory Allocationmalloc() in C – Dynamic Memory AllocationComplete guide to malloc() in C programming — syntax, usage, allocating memory at runtime, checking for NULL, typecasting, practical examples with output, and common mistakes to avoid.Dynamic Memory AllocationMemory Management Best Practices in CComplete guide to memory management best practices in C — preventing memory leaks, using Valgrind, ownership patterns, RAII-like cleanup, common pitfalls, and professional coding patterns for safe dynamic memory.Dynamic Memory Allocationrealloc() in C – Resizing Dynamic MemoryComplete guide to realloc() in C programming — syntax, resizing allocated memory, handling reallocation failures safely, shrinking and growing memory blocks, practical examples with output.Advanced CFunction Pointers in C – Complete Guide with ExamplesLearn function pointers in C programming with syntax, callbacks, qsort usage, arrays of function pointers, and practical examples for building flexible programs.