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 binary file handling in C — reading and writing binary data with fread/fwrite, struct serialization, random access with fseek, database-like operations, practical examples.
Text files store everything as readable characters — the number 12345 takes 5 bytes (one per digit). Binary files store data in the same format as memory — the same number takes just 4 bytes (sizeof(int)). For structured data like records, images, or databases, binary files are faster, more compact, and easier to work with.
Why Binary Files?
| Aspect | Text File | Binary File |
|---|---|---|
Storage of int 12345 | 5 bytes ("12345") | 4 bytes (raw bits) |
Storage of float 3.14 | 4 bytes ("3.14") | 4 bytes (IEEE 754) |
| Reading speed | Parse strings → numbers | Direct memory copy |
| Struct storage | Must serialize each field | Write entire struct at once |
| Human readable | Yes | No |
| Portability | High | Low (endianness, padding) |
Writing Structures to Binary Files
Example
#include <stdio.h>
#include <string.h>
struct Employee {
int id;
char name[30];
float salary;
int department;
};
int main() {
struct Employee team[] = {
{1, "Alice Johnson", 85000.0, 101},
{2, "Bob Smith", 72000.0, 102},
{3, "Charlie Brown", 91000.0, 101},
{4, "Diana Prince", 68000.0, 103},
{5, "Eve Wilson", 79000.0, 102}
};
int n = 5;
FILE *fp = fopen("employees.dat", "wb");
if (fp == NULL) {
printf("Cannot create file!\n");
return 1;
}
// Write all records at once
size_t written = fwrite(team, sizeof(struct Employee), n, fp);
fclose(fp);
printf("Wrote %zu employee records (%zu bytes total)\n",
written, written * sizeof(struct Employee));
return 0;
}
Output
Wrote 5 employee records (220 bytes total)
Reading Structures from Binary Files
Example
#include <stdio.h>
struct Employee {
int id;
char name[30];
float salary;
int department;
};
int main() {
FILE *fp = fopen("employees.dat", "rb");
if (fp == NULL) {
printf("Cannot open file!\n");
return 1;
}
struct Employee emp;
printf("%-4s %-20s %10s %s\n", "ID", "Name", "Salary", "Dept");
printf("──────────────────────────────────────────────\n");
while (fread(&emp, sizeof(struct Employee), 1, fp) == 1) {
printf("%-4d %-20s %10.2f %d\n",
emp.id, emp.name, emp.salary, emp.department);
}
fclose(fp);
return 0;
}
Output
ID Name Salary Dept ────────────────────────────────────────────── 1 Alice Johnson 85000.00 101 2 Bob Smith 72000.00 102 3 Charlie Brown 91000.00 101 4 Diana Prince 68000.00 103 5 Eve Wilson 79000.00 102
Random Access with fseek()
Binary files enable jumping directly to any record:
Example
#include <stdio.h>
struct Record {
int id;
char name[20];
float value;
};
int main() {
// Create test file
FILE *fp = fopen("records.dat", "wb");
struct Record records[] = {
{1, "First", 100.0},
{2, "Second", 200.0},
{3, "Third", 300.0},
{4, "Fourth", 400.0},
{5, "Fifth", 500.0}
};
fwrite(records, sizeof(struct Record), 5, fp);
fclose(fp);
// Random access — read record #3 directly
fp = fopen("records.dat", "rb");
if (fp == NULL) return 1;
struct Record r;
int target = 3; // Want record at index 2 (0-based)
// Jump directly to the record
fseek(fp, (target - 1) * sizeof(struct Record), SEEK_SET);
fread(&r, sizeof(struct Record), 1, fp);
printf("Record #%d: id=%d, name=%s, value=%.1f\n",
target, r.id, r.name, r.value);
fclose(fp);
return 0;
}
Output
Record #3: id=3, name=Third, value=300.0
Memory Diagram: Binary File Layout
| Record 1 | Record 2 | Record 3 | Record 4 | Record 5 |
|---|---|---|---|---|
| 28 bytes | 28 bytes | 28 bytes | 28 bytes | 28 bytes |
Updating a Specific Record
Example
#include <stdio.h>
struct Student {
int roll;
char name[30];
float marks;
};
int main() {
// Open for both reading and writing
FILE *fp = fopen("students.dat", "rb+");
if (fp == NULL) {
printf("File not found!\n");
return 1;
}
// Find and update record with roll 3
struct Student s;
int found = 0;
while (fread(&s, sizeof(struct Student), 1, fp) == 1) {
if (s.roll == 3) {
s.marks = 98.5; // Update marks
// Move back one record to overwrite
fseek(fp, -sizeof(struct Student), SEEK_CUR);
fwrite(&s, sizeof(struct Student), 1, fp);
found = 1;
break;
}
}
fclose(fp);
printf(found ? "Record updated!\n" : "Record not found!\n");
return 0;
}
Output
Record updated!
Counting Records in a Binary File
Example
#include <stdio.h>
struct Record {
int id;
char data[50];
};
int count_records(const char *filename) {
FILE *fp = fopen(filename, "rb");
if (fp == NULL) return -1;
fseek(fp, 0, SEEK_END); // Go to end
long file_size = ftell(fp); // Get position (= file size)
fclose(fp);
return file_size / sizeof(struct Record);
}
int main() {
int n = count_records("data.dat");
if (n >= 0) {
printf("File contains %d records\n", n);
}
return 0;
}
Deleting a Record (Copy-Overwrite Method)
Example
#include <stdio.h>
#include <string.h>
struct Contact {
int id;
char name[30];
char phone[15];
};
int delete_record(const char *filename, int target_id) {
FILE *fp = fopen(filename, "rb");
FILE *temp = fopen("temp.dat", "wb");
if (fp == NULL || temp == NULL) return -1;
struct Contact c;
int deleted = 0;
while (fread(&c, sizeof(struct Contact), 1, fp) == 1) {
if (c.id != target_id) {
fwrite(&c, sizeof(struct Contact), 1, temp);
} else {
deleted = 1;
}
}
fclose(fp);
fclose(temp);
// Replace original with temp
remove(filename);
rename("temp.dat", filename);
return deleted;
}
int main() {
if (delete_record("contacts.dat", 3)) {
printf("Record deleted successfully.\n");
} else {
printf("Record not found.\n");
}
return 0;
}
fseek() Modes
| Mode | Constant | Seeks from |
|---|---|---|
| Beginning | SEEK_SET | Start of file (offset 0) |
| Current | SEEK_CUR | Current position |
| End | SEEK_END | End of file |
c example
fseek(fp, 0, SEEK_SET); // Go to beginning
fseek(fp, 0, SEEK_END); // Go to end
fseek(fp, 100, SEEK_SET); // Go to byte 100 from start
fseek(fp, -28, SEEK_CUR); // Go back 28 bytes from currentInterview Questions
Q1: Why can't you just use fprintf/fscanf for structs?
You could, but you'd have to serialize each field individually, handle formatting, and parse it back. Binary fwrite/fread copies the struct directly — one call writes the entire record exactly as it exists in memory. It's faster and simpler for fixed-size structures.
Q2: What are the portability issues with binary files?
Binary files depend on: (1) endianness (byte order — x86 is little-endian, some ARM is big-endian), (2) struct padding (varies by compiler and settings), (3) type sizes (int may be 2 or 4 bytes). A binary file written on one system may not read correctly on another.
Q3: How do you implement deletion in a binary file?
Two approaches: (1) Copy all records except the target to a new file, then replace the original (safe but slow). (2) Mark records as deleted with a flag field and skip them during reads (fast but wastes space — needs periodic compaction).
Q4: What is random access and why do binary files support it?
Random access means jumping directly to any position in the file without reading everything before it. Binary files support this because records have fixed sizes — record N is at offset N * sizeof(record). Text files have variable-length lines, making random access impractical.
Summary
- Binary files store data in raw memory format — compact and fast
fwrite()writes structs/arrays directly;fread()reads them backfseek()enables random access to any record by calculating offsets- Record N is at position
(N-1) * sizeof(struct)from the start - Use
"rb"and"wb"modes for binary operations - Binary files are not portable across different architectures
- For deletion, use copy-to-temp or mark-as-deleted approaches
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Binary Files in C – fread and fwrite.
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, file, handling, binary, files, binary files in c – fread and fwrite
Related C Programming Topics
Continue learning this concept
File Handlingfopen() and fclose() in C – Opening and Closing FilesComplete guide to fopen() and fclose() in C — file opening modes, error checking, file paths, buffering, practical examples with output, and best practices for file management.File HandlingReading Files in C – fgetc, fgets, fscanf, freadComplete guide to reading files in C — character-by-character with fgetc, line-by-line with fgets, formatted reading with fscanf, block reading with fread, practical examples with output.File HandlingWriting Files in C – fputc, fputs, fprintf, fwriteComplete guide to writing files in C — character writing with fputc, string writing with fputs, formatted output with fprintf, binary writing with fwrite, practical examples with output.File HandlingFile Handling in C – IntroductionComplete introduction to file handling in C programming — what are files, why file I/O is needed, types of files (text vs binary), file operations overview, streams, FILE pointer concept with examples.File HandlingFile Handling Projects in C – Student Records & Phone BookComplete file handling project examples in C — student record management system, phone book application with add/search/delete/display operations, menu-driven programs with binary files.File HandlingFile Modes in C – Complete GuideComplete guide to file modes in C — r, w, a, r+, w+, a+ modes, binary modes rb/wb/ab, mode comparison table, choosing the right mode, practical examples with output.