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
Top memory management interview questions for C programming covering malloc, calloc, free, memory leaks, segmentation faults, stack vs heap, and dynamic allocation.
Memory management is the cornerstone of C programming and the area where most bugs and interview questions originate. Unlike managed languages with garbage collection, C requires you to manually allocate and free memory. This guide covers the most important memory management questions asked in technical interviews.
Core Concepts
Q1: What are the four memory allocation functions in C?
c example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
// malloc: allocates uninitialized memory
int *p1 = (int*)malloc(5 * sizeof(int));
// calloc: allocates zero-initialized memory
int *p2 = (int*)calloc(5, sizeof(int));
// realloc: resizes previously allocated memory
p1 = (int*)realloc(p1, 10 * sizeof(int));
// free: releases allocated memory
free(p1);
free(p2);
return 0;
}| Function | Syntax | Initializes | Use Case |
|---|---|---|---|
| malloc | malloc(bytes) | No (garbage) | General allocation |
| calloc | calloc(count, size) | Yes (zeros) | Arrays, zero-init needed |
| realloc | realloc(ptr, new_size) | Preserves old data | Growing/shrinking buffers |
| free | free(ptr) | N/A | Release memory |
Q2: What happens if malloc fails?
c example
#include <stdio.h>
#include <stdlib.h>
int main() {
// malloc returns NULL on failure
int *ptr = (int*)malloc(sizeof(int) * 1000000000L);
if (ptr == NULL) {
fprintf(stderr, "Memory allocation failed!\n");
return 1; // Handle gracefully
}
// Use ptr safely...
free(ptr);
return 0;
}Answer: malloc returns NULL when it cannot allocate the requested memory. Always check the return value before using the pointer.
Q3: What is a memory leak? How to detect it?
c example
#include <stdlib.h>
void memory_leak_example() {
int *p = (int*)malloc(100 * sizeof(int));
// Function returns without free(p) - MEMORY LEAK!
// The allocated memory is inaccessible but not freed
}
void no_leak_example() {
int *p = (int*)malloc(100 * sizeof(int));
if (p == NULL) return;
// ... use p ...
free(p); // Properly freed
}
// Overwriting pointer without freeing - another common leak
void overwrite_leak() {
int *p = (int*)malloc(sizeof(int));
*p = 10;
p = (int*)malloc(sizeof(int)); // First allocation lost!
*p = 20;
free(p); // Only second allocation freed
}Detection methods:
- Valgrind:
valgrind --leak-check=full ./program - AddressSanitizer: compile with
-fsanitize=address - Custom allocation tracking with wrappers
Q4: What is a double-free bug?
c example
#include <stdlib.h>
int main() {
int *p = (int*)malloc(sizeof(int));
*p = 42;
free(p);
// free(p); // DOUBLE FREE - Undefined Behavior!
// Prevention: set to NULL after free
p = NULL;
free(p); // safe - free(NULL) is a no-op
return 0;
}Answer: Freeing the same memory twice causes undefined behavior – heap corruption, crashes, or security vulnerabilities. Always set pointers to NULL after freeing.
Q5: What is use-after-free?
c example
#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int*)malloc(sizeof(int));
*p = 42;
printf("Before free: %d\n", *p);
free(p);
// DANGEROUS: p still holds the old address
// printf("After free: %d\n", *p); // USE-AFTER-FREE! UB!
// Prevention:
p = NULL;
// Now any access through p will clearly crash (NULL deref)
return 0;
}Q6: Difference between stack and heap allocation?
Example
#include <stdio.h>
#include <stdlib.h>
int* stack_danger() {
int x = 42; // Stack allocated
return &x; // DANGER: x destroyed after return!
}
int* heap_safe() {
int *x = (int*)malloc(sizeof(int)); // Heap allocated
*x = 42;
return x; // Safe: lives until free() is called
}
int main() {
// Stack allocation
int arr[100]; // Fast, automatic, size must be known at compile time
// Heap allocation
int n = 100;
int *darr = (int*)malloc(n * sizeof(int)); // Size determined at runtime
free(darr);
return 0;
}
Q7: What does realloc do in different scenarios?
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
// Scenario 1: realloc(NULL, size) = malloc(size)
int *p = (int*)realloc(NULL, 5 * sizeof(int));
for (int i = 0; i < 5; i++) p[i] = i + 1;
// Scenario 2: Enlarge - may move memory
int *temp = (int*)realloc(p, 10 * sizeof(int));
if (temp == NULL) {
// realloc failed - original p is still valid!
free(p);
return 1;
}
p = temp;
// Scenario 3: realloc(ptr, 0) - implementation defined
// Some implementations free the memory, some don't
// Don't rely on this - use free() explicitly
// Scenario 4: Shrink
temp = (int*)realloc(p, 2 * sizeof(int));
if (temp) p = temp;
printf("p[0]=%d, p[1]=%d\n", p[0], p[1]);
free(p);
return 0;
}
Output
p[0]=1, p[1]=2
Important: Always assign realloc's return to a temporary variable. If realloc fails, it returns NULL but doesn't free the original memory.
Q8: What is buffer overflow and how to prevent it?
Example
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// VULNERABLE
void vulnerable(const char *input) {
char buffer[10];
strcpy(buffer, input); // No bounds check!
}
// SAFE
void safe(const char *input) {
char buffer[10];
strncpy(buffer, input, sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';
}
// BETTER: Dynamic allocation
char* safe_dynamic(const char *input) {
size_t len = strlen(input);
char *buffer = (char*)malloc(len + 1);
if (!buffer) return NULL;
strcpy(buffer, input); // Safe: buffer is exactly the right size
return buffer;
}
int main() {
safe("Hello");
char *s = safe_dynamic("This can be any length safely");
printf("%s\n", s);
free(s);
return 0;
}
Q9: How does free() know how many bytes to release?
Answer: The memory allocator stores metadata (usually just before the returned pointer) that records the size of the allocation. When you call free(ptr), it looks at this hidden header to determine how much memory to release. This is why:
- You must pass the exact pointer returned by malloc (not an offset)
- Passing a non-malloc'd pointer to free is undefined behavior
- Buffer overflows can corrupt this metadata, causing heap corruption
Q10: What is fragmentation?
c example
#include <stdio.h>
#include <stdlib.h>
int main() {
// Allocate and free in a pattern that causes fragmentation
void *p1 = malloc(100);
void *p2 = malloc(200);
void *p3 = malloc(100);
void *p4 = malloc(200);
void *p5 = malloc(100);
// Free every other block
free(p1); // 100 bytes free
free(p3); // 100 bytes free
free(p5); // 100 bytes free
// Now 300 bytes total are free, but:
// Can we allocate 250 bytes? Maybe NOT!
// The free blocks are 100 bytes each, non-contiguous
void *big = malloc(250);
printf("Large allocation: %s\n", big ? "Success" : "Failed");
free(p2);
free(p4);
if (big) free(big);
return 0;
}Answer: Fragmentation occurs when free memory is broken into small, non-contiguous blocks. Even if total free memory is sufficient, a large allocation might fail because no single contiguous block is big enough.
Q11: What is the memory layout of a dynamically allocated 2D array?
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
int rows = 3, cols = 4;
// Method 1: Array of pointers (rows may not be contiguous)
int **arr1 = (int**)malloc(rows * sizeof(int*));
for (int i = 0; i < rows; i++)
arr1[i] = (int*)malloc(cols * sizeof(int));
// Method 2: Single contiguous block (better cache performance)
int *arr2 = (int*)malloc(rows * cols * sizeof(int));
// Access: arr2[i * cols + j]
// Method 3: Contiguous with row pointers
int **arr3 = (int**)malloc(rows * sizeof(int*));
arr3[0] = (int*)malloc(rows * cols * sizeof(int));
for (int i = 1; i < rows; i++)
arr3[i] = arr3[0] + i * cols;
// Set and print using Method 3
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++)
arr3[i][j] = i * cols + j;
printf("arr3[1][2] = %d\n", arr3[1][2]);
// Free
for (int i = 0; i < rows; i++) free(arr1[i]);
free(arr1);
free(arr2);
free(arr3[0]);
free(arr3);
return 0;
}
Output
arr3[1][2] = 6
Q12: What happens when you free memory that wasn't allocated by malloc?
c example
#include <stdlib.h>
int main() {
int x = 10;
int *p = &x;
// free(p); // UNDEFINED BEHAVIOR! x is on stack, not heap
int *arr = (int*)malloc(10 * sizeof(int));
// free(arr + 5); // UNDEFINED BEHAVIOR! Not the original pointer
free(arr); // Correct: pass the original pointer
return 0;
}Q13: Implement a safe memory allocation wrapper
Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void* safe_malloc(size_t size, const char *file, int line) {
if (size == 0) {
fprintf(stderr, "[%s:%d] Warning: zero-size allocation\n", file, line);
return NULL;
}
void *ptr = malloc(size);
if (!ptr) {
fprintf(stderr, "[%s:%d] Fatal: malloc(%zu) failed\n", file, line, size);
exit(EXIT_FAILURE);
}
return ptr;
}
#define MALLOC(size) safe_malloc(size, __FILE__, __LINE__)
int main() {
int *data = (int*)MALLOC(100 * sizeof(int));
memset(data, 0, 100 * sizeof(int));
data[0] = 42;
printf("data[0] = %d\n", data[0]);
free(data);
return 0;
}
Output
data[0] = 42
Common Memory Bugs Summary
| Bug | Cause | Prevention |
|---|---|---|
| Memory Leak | Forgetting to free | Always pair malloc/free, use tools |
| Double Free | Freeing twice | Set ptr to NULL after free |
| Use-After-Free | Accessing freed memory | NULL after free, scope discipline |
| Buffer Overflow | Writing past allocation | Bounds checking, safe functions |
| Dangling Pointer | Pointer to freed/invalid memory | NULL after free, careful lifetimes |
| Uninitialized Read | Reading malloc'd memory | Use calloc, or initialize immediately |
Interview Questions Summary
Q14: Can you allocate memory for a flexible array member? Yes – struct S { int count; int data[]; }; then malloc(sizeof(struct S) + n * sizeof(int)).
Q15: What is memory alignment? The requirement that data types be stored at addresses that are multiples of their size. Misaligned access can be slow or crash on some architectures.
Q16: What is alloca()? Allocates memory on the stack (freed automatically when function returns). Non-standard, dangerous for large allocations (stack overflow), but very fast.
Summary
Memory management in C requires understanding allocation mechanisms, ownership rules, and common pitfalls. Always check malloc returns, free exactly once, never access freed memory, and use tools like Valgrind and ASan during development. The interviewer wants to see that you understand not just the API, but the consequences of getting it wrong – security vulnerabilities, crashes, and data corruption.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Memory Management Interview Questions in C with Answers.
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, interview, preparation, memory, management, questions
Related C Programming Topics
Continue learning this concept
Interview PreparationTop 50 C Programming Interview Questions with Answers (2025)Comprehensive collection of 50 most asked C programming interview questions with detailed answers covering basics, pointers, memory, strings, and advanced topics.Interview PreparationOutput Prediction Questions in C – What Will This Program Print?Practice C output-based interview questions covering operator precedence, pointer tricks, type promotion, undefined behavior, and tricky printf scenarios.Interview PreparationPointer Interview Questions in C – Tricky Problems with AnswersMaster tricky pointer interview questions in C covering pointer arithmetic, pointer to pointer, function pointers, array-pointer relationships, and common pitfalls.Interview PreparationC Programming Cheatsheet – Complete Quick Reference GuideComprehensive C programming cheatsheet covering syntax, data types, operators, control flow, pointers, strings, file I/O, memory management, and common patterns.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.Advanced CMemory Layout of a C Program – Text, Data, BSS, Heap, StackUnderstand the complete memory layout of a C program including text segment, data segment, BSS, heap, and stack with diagrams, examples, and interview questions.