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 calloc() in C programming — syntax, zero-initialization, difference from malloc, practical examples with output, when to use calloc vs malloc, and common interview questions.
While malloc() gives you a raw block of uninitialized memory, calloc() does something more thoughtful — it allocates memory and initializes every byte to zero. The name stands for contiguous allocation, and it's especially useful when you need a clean slate of memory.
Syntax of calloc()
c example
void *calloc(size_t num, size_t size);| Parameter | Description |
|---|---|
num | Number of elements to allocate |
size | Size of each element in bytes |
| Return value | Pointer to zero-initialized memory, or NULL on failure |
Notice the difference from malloc: calloc takes two arguments. Instead of calculating the total bytes yourself, you specify how many items and how big each item is.
How calloc() Works
calloc(5, sizeof(int)) → Allocates 5 × 4 = 20 bytes, all set to 0
┌─────────────────────────────────────────────┐
│ HEAP │
│ ┌─────┬─────┬─────┬─────┬─────┐ │
│ │ 0 │ 0 │ 0 │ 0 │ 0 │ │
│ └─────┴─────┴─────┴─────┴─────┘ │
│ (20 bytes allocated, ALL initialized to 0) │
└─────────────────────────────────────────────┘
Basic calloc() Example
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
int *arr;
int n = 5;
// Allocate memory for 5 integers (zero-initialized)
arr = (int *)calloc(n, sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// Print values — all will be 0
printf("Values after calloc (all zeros):\n");
for (int i = 0; i < n; i++) {
printf("arr[%d] = %d\n", i, arr[i]);
}
// Now assign some values
for (int i = 0; i < n; i++) {
arr[i] = i * i;
}
printf("\nAfter assignment:\n");
for (int i = 0; i < n; i++) {
printf("arr[%d] = %d\n", i, arr[i]);
}
free(arr);
return 0;
}
Output
Values after calloc (all zeros): arr[0] = 0 arr[1] = 0 arr[2] = 0 arr[3] = 0 arr[4] = 0 After assignment: arr[0] = 0 arr[1] = 1 arr[2] = 4 arr[3] = 9 arr[4] = 16
calloc() vs malloc() – Key Differences
| Feature | malloc() | calloc() |
|---|---|---|
| Syntax | malloc(size) | calloc(num, size) |
| Arguments | 1 (total bytes) | 2 (count, element size) |
| Initialization | Garbage values | Zero-initialized |
| Speed | Slightly faster | Slightly slower (due to zeroing) |
| Overflow check | No | Yes (checks num × size overflow) |
| Use case | When you'll overwrite immediately | When zero-init matters |
Demonstrating the Difference
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
int *m_arr, *c_arr;
int n = 5;
// malloc - contains garbage
m_arr = (int *)malloc(n * sizeof(int));
// calloc - contains zeros
c_arr = (int *)calloc(n, sizeof(int));
if (m_arr == NULL || c_arr == NULL) {
printf("Allocation failed!\n");
return 1;
}
printf("malloc values (garbage):\n");
for (int i = 0; i < n; i++) {
printf(" m_arr[%d] = %d\n", i, m_arr[i]);
}
printf("\ncalloc values (zeros):\n");
for (int i = 0; i < n; i++) {
printf(" c_arr[%d] = %d\n", i, c_arr[i]);
}
free(m_arr);
free(c_arr);
return 0;
}
Output
malloc values (garbage): m_arr[0] = 1852730451 m_arr[1] = 7565156 m_arr[2] = 0 m_arr[3] = 1769234802 m_arr[4] = 2036691 calloc values (zeros): c_arr[0] = 0 c_arr[1] = 0 c_arr[2] = 0 c_arr[3] = 0 c_arr[4] = 0
When to Use calloc() Over malloc()
Use calloc() when:
- Counters and accumulators — Starting from zero makes logical sense
- Lookup tables — Zero means "not set" or "empty"
- Graph adjacency matrices — Zero means "no edge"
- Boolean flag arrays — Zero means false
- Security-sensitive code — Prevents information leakage from uninitialized memory
Practical Example: Frequency Counter
Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
// Count frequency of each lowercase letter
int *freq = (int *)calloc(26, sizeof(int));
if (freq == NULL) {
printf("Allocation failed!\n");
return 1;
}
char text[] = "hello world programming in c";
// Count letters — works because calloc initialized to 0
for (int i = 0; i < strlen(text); i++) {
if (text[i] >= 'a' && text[i] <= 'z') {
freq[text[i] - 'a']++;
}
}
printf("Letter frequencies:\n");
for (int i = 0; i < 26; i++) {
if (freq[i] > 0) {
printf(" '%c' = %d\n", 'a' + i, freq[i]);
}
}
free(freq);
return 0;
}
Output
Letter frequencies: 'a' = 1 'c' = 1 'd' = 1 'e' = 1 'g' = 2 'h' = 1 'i' = 2 'l' = 3 'm' = 2 'n' = 2 'o' = 3 'p' = 1 'r' = 3 'w' = 1
calloc() for 2D Arrays
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
int rows = 3, cols = 4;
// Allocate array of row pointers
int **matrix = (int **)calloc(rows, sizeof(int *));
if (matrix == NULL) return 1;
// Allocate each row
for (int i = 0; i < rows; i++) {
matrix[i] = (int *)calloc(cols, sizeof(int));
if (matrix[i] == NULL) return 1;
}
// All elements are already 0 — set some values
matrix[0][0] = 1;
matrix[1][1] = 5;
matrix[2][3] = 9;
// Print the matrix
printf("Matrix:\n");
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%3d ", matrix[i][j]);
}
printf("\n");
}
// Free in reverse order
for (int i = 0; i < rows; i++) {
free(matrix[i]);
}
free(matrix);
return 0;
}
Output
Matrix: 1 0 0 0 0 5 0 0 0 0 0 9
Overflow Safety of calloc()
One subtle advantage of calloc(num, size) over malloc(num * size) is overflow detection:
c example
// DANGEROUS: if num is huge, num * sizeof(int) can overflow silently
size_t num = 1000000000000;
int *p = (int *)malloc(num * sizeof(int)); // Overflow → allocates tiny block!
// SAFER: calloc checks for multiplication overflow internally
int *q = (int *)calloc(num, sizeof(int)); // Returns NULL on overflowSimulating calloc() with malloc() + memset()
Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Equivalent to calloc(n, size)
void *my_calloc(size_t n, size_t size) {
size_t total = n * size;
void *ptr = malloc(total);
if (ptr != NULL) {
memset(ptr, 0, total); // Set all bytes to 0
}
return ptr;
}
int main() {
int *arr = (int *)my_calloc(5, sizeof(int));
if (arr != NULL) {
for (int i = 0; i < 5; i++) {
printf("arr[%d] = %d\n", i, arr[i]);
}
free(arr);
}
return 0;
}
Output
arr[0] = 0 arr[1] = 0 arr[2] = 0 arr[3] = 0 arr[4] = 0
Interview Questions
Q1: What is the main difference between malloc() and calloc()?
malloc() takes one argument (total bytes) and returns uninitialized memory. calloc() takes two arguments (count and element size) and returns zero-initialized memory. calloc() is slightly slower because it must write zeros to the entire block.
Q2: Does calloc() guarantee zero-initialization for all types?
calloc() sets all bytes to zero. For integers and pointers, this is equivalent to the value 0. However, for floating-point numbers, all-bits-zero is 0.0 on IEEE 754 systems (which is virtually all modern systems), but this is technically implementation-defined.
Q3: When would you prefer malloc() over calloc()?
When you plan to immediately overwrite every allocated byte (e.g., reading file contents into a buffer). The zero-initialization of calloc() would be wasted work in that case, so malloc() is more efficient.
Q4: Can calloc() fail?
Yes. Like malloc(), calloc() returns NULL when the system cannot satisfy the memory request. Additionally, calloc() may fail if the multiplication of num * size would overflow.
Summary
calloc()allocates memory for an array of elements and initializes all bytes to zero- Syntax:
calloc(num_elements, size_per_element) - Safer than
malloc(n * size)because it checks for integer overflow - Use calloc() when zero-initialization is meaningful (counters, flags, lookup tables)
- Use malloc() when you'll overwrite the data immediately
- Always check for NULL and always free the memory when done
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for calloc() in C – Contiguous Memory Allocation.
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, calloc, calloc() in c – contiguous memory allocation
Related C Programming Topics
Continue learning this concept
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 Allocationfree() in C – Releasing Dynamic MemoryComplete guide to free() in C programming — releasing heap memory, dangling pointers, double-free errors, memory leaks, best practices for safe deallocation with practical examples.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 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.