Offensive Security Researcher & Quantum Cryptography Analyst

Working with Files in C: File Handling, Reading, Writing, and Management

Abdul Wahab Junaid
Working with Files in C

Working with Files in C

Every C program I’ve written that deals with real data eventually needs to talk to files — logs, configuration, saved state, exported reports, whatever it is. And file handling in C is one of those topics that looks simple on the surface (fopen, fprintf, fclose) but has a surprising amount of depth once you start caring about binary data, error handling, buffering, and file management at the OS level.

In this guide, I’ll take you from opening your very first file all the way through binary I/O, random access, buffering internals, and the mistakes that cause real bugs in production code.

Table of Contents

  1. Why File Handling Matters
  2. The FILE Pointer and Streams
  3. Opening and Closing Files
  4. Reading and Writing Text Files
  5. Reading and Writing Binary Files
  6. Sequential vs. Random Access
  7. File Positioning Functions
  8. Error Handling in File Operations
  9. File Management: Renaming, Deleting, and Checking Existence
  10. Internal Working: Buffering and the OS Layer
  11. Best Practices
  12. Performance Optimization
  13. Debugging File I/O Issues
  14. Common Mistakes
  15. Real-World Applications
  16. Interview Questions
  17. FAQs
  18. Summary and Key Takeaways
  19. References

1. Why File Handling Matters

Without file handling, a program’s data disappears the moment it exits — everything lives only in RAM. Files give your programs persistence: the ability to save results, read configuration, process large datasets that don’t fit in memory, and exchange data with other programs. Nearly every serious C application — from a simple to-do list tool to a database engine — depends on solid file I/O.

2. The FILE Pointer and Streams

C treats files as streams of bytes, and you interact with a stream through a FILE * pointer, declared in <stdio.h>.

#include <stdio.h>

int main(void) {
    FILE *fp; // pointer to a FILE structure managed by the C library
    fp = fopen("example.txt", "w");

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    fprintf(fp, "Hello, file handling in C!\n");
    fclose(fp);

    printf("File written successfully.\n");
    return 0;
}

Output:

File written successfully.

The FILE structure itself is opaque to you — it’s maintained internally by the standard library and contains things like the current position indicator, a buffer, and an error/EOF flag. You never touch its internals directly; you always go through the standard functions.

3. Opening and Closing Files

fopen() takes a filename and a mode string:

ModeMeaning
"r"Read (file must exist)
"w"Write (creates new or truncates existing)
"a"Append (creates if not exists, writes at end)
"r+"Read and write (file must exist)
"w+"Read and write (truncates or creates)
"a+"Read and append
"rb", "wb", etc.Same as above, binary mode
#include <stdio.h>

int main(void) {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {
        perror("fopen failed");
        return 1;
    }

    // ... work with the file ...

    if (fclose(fp) != 0) {
        perror("fclose failed");
        return 1;
    }

    return 0;
}

Always check fopen‘s return value. A NULL return means the file couldn’t be opened — maybe it doesn’t exist, maybe you lack permissions. Always call fclose() when you’re done; it flushes any buffered data to disk and releases the file handle. Forgetting to close files is a resource leak that can eventually exhaust your program’s available file descriptors.

4. Reading and Writing Text Files

Writing with fprintf and fputs

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("notes.txt", "w");
    if (fp == NULL) {
        perror("Error");
        return 1;
    }

    fprintf(fp, "Line %d: %s\n", 1, "First entry");
    fputs("Second entry\n", fp);

    fclose(fp);
    return 0;
}

Reading with fgets

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("notes.txt", "r");
    char buffer[100];

    if (fp == NULL) {
        perror("Error");
        return 1;
    }

    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }

    fclose(fp);
    return 0;
}

Output:

Line 1: First entry
Second entry

fgets is the safer choice over gets() (which is so dangerous it was removed from the C11 standard entirely) because it takes a buffer size and won’t overflow it. Always prefer fgets for reading lines of text.

Reading Formatted Data with fscanf

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("scores.txt", "r");
    char name[50];
    int score;

    if (fp == NULL) {
        perror("Error");
        return 1;
    }

    while (fscanf(fp, "%49s %d", name, &score) == 2) {
        printf("Name: %s, Score: %d\n", name, score);
    }

    fclose(fp);
    return 0;
}

Note the %49s — limiting the field width prevents a buffer overflow if a line is longer than expected. Always check fscanf‘s return value (the number of successfully matched items) rather than assuming the read succeeded.

5. Reading and Writing Binary Files

Binary I/O is for raw data — structures, images, serialized objects — where you want the exact byte representation, not a human-readable text conversion.

#include <stdio.h>

typedef struct {
    int id;
    char name[30];
    float salary;
} Employee;

int main(void) {
    Employee e1 = {101, "Ali Raza", 55000.50f};

    FILE *fp = fopen("employee.dat", "wb");
    if (fp == NULL) {
        perror("Error");
        return 1;
    }
    fwrite(&e1, sizeof(Employee), 1, fp);
    fclose(fp);

    Employee e2;
    fp = fopen("employee.dat", "rb");
    if (fp == NULL) {
        perror("Error");
        return 1;
    }
    fread(&e2, sizeof(Employee), 1, fp);
    fclose(fp);

    printf("ID: %d\n", e2.id);
    printf("Name: %s\n", e2.name);
    printf("Salary: %.2f\n", e2.salary);

    return 0;
}

Output:

ID: 101
Name: Ali Raza
Salary: 55000.50

fwrite/fread copy the exact in-memory bytes of the structure to/from the file. This is fast and simple, but be aware: binary files written this way aren’t portable across machines with different endianness, struct padding, or int/float sizes. For truly portable binary formats, you’d serialize fields individually in a fixed, documented byte order.

6. Sequential vs. Random Access

Sequential access reads or writes a file from beginning to end, in order — the default behavior of the functions above. Random access lets you jump to any position in the file using fseek(), which is essential when working with fixed-size records (like our Employee struct) where you know exactly how many bytes to skip to reach record number N.

#include <stdio.h>

typedef struct {
    int id;
    char name[30];
} Record;

int main(void) {
    FILE *fp = fopen("records.dat", "rb");
    if (fp == NULL) {
        perror("Error");
        return 1;
    }

    int index = 2; // 0-based: fetch the 3rd record directly
    fseek(fp, index * sizeof(Record), SEEK_SET);

    Record r;
    fread(&r, sizeof(Record), 1, fp);
    printf("Record %d -> ID: %d, Name: %s\n", index, r.id, r.name);

    fclose(fp);
    return 0;
}

Random access is what makes database-like lookups on flat binary files possible without reading the whole file into memory.

7. File Positioning Functions

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("notes.txt", "r");
    if (fp == NULL) {
        perror("Error");
        return 1;
    }

    fseek(fp, 0, SEEK_END);
    long size = ftell(fp);
    printf("File size: %ld bytes\n", size);

    rewind(fp);
    printf("Position after rewind: %ld\n", ftell(fp));

    fclose(fp);
    return 0;
}

This “seek to end, ftell, rewind” pattern is a common trick for finding a file’s size before reading it fully into a buffer.

8. Error Handling in File Operations

Never assume a file operation succeeded. Use perror(), ferror(), and feof() to handle failures gracefully.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("missing.txt", "r");

    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }

    char buffer[50];
    while (fgets(buffer, sizeof(buffer), fp)) {
        printf("%s", buffer);
    }

    if (ferror(fp)) {
        fprintf(stderr, "A read error occurred\n");
    } else if (feof(fp)) {
        printf("Reached end of file normally\n");
    }

    fclose(fp);
    return 0;
}

perror() prints a human-readable message based on the global errno, which is set by the failing system call — this is far more informative than a generic “something went wrong” message.

9. File Management: Renaming, Deleting, and Checking Existence

The <stdio.h> library provides basic file management beyond reading/writing:

#include <stdio.h>

int main(void) {
    if (rename("old_name.txt", "new_name.txt") == 0) {
        printf("File renamed successfully\n");
    } else {
        perror("Rename failed");
    }

    if (remove("temporary.txt") == 0) {
        printf("File deleted successfully\n");
    } else {
        perror("Delete failed");
    }

    return 0;
}

To check if a file exists without necessarily reading it, a common trick is attempting to open it in read mode and checking for NULL:

FILE *fp = fopen("check.txt", "r");
if (fp != NULL) {
    printf("File exists\n");
    fclose(fp);
} else {
    printf("File does not exist\n");
}

10. Internal Working: Buffering and the OS Layer

When you call fprintf or fwrite, the data usually doesn’t hit the disk immediately. The C standard library maintains an internal buffer for each open stream. Data accumulates there and is flushed to the operating system in larger chunks — this dramatically reduces the number of actual system calls, which are expensive compared to writing to memory.

There are three buffering modes:

You can force a flush manually:

fflush(fp); // pushes buffered data out to the OS immediately

Below the C library sits the operating system’s own layer — file descriptors, the page cache, and eventually the physical disk. A FILE * from the standard library actually wraps a lower-level file descriptor (on POSIX systems, obtainable through fileno(fp)), which is what the OS itself uses for system calls like read() and write(). Understanding these two layers explains why fclose() (or fflush()) is essential — without it, your last chunk of data might still be sitting in the library’s buffer when your program exits, and depending on how it exits, could be lost.

11. Best Practices

12. Performance Optimization

13. Debugging File I/O Issues

14. Common Mistakes

  1. Forgetting to check if fopen() returned NULL.
  2. Mixing up read/write modes — trying to fprintf to a file opened with "r".
  3. Not closing files, leading to file descriptor leaks and locked files.
  4. Using gets() (removed from the standard for good reason) or unbounded scanf("%s").
  5. Assuming binary struct files are portable across machines or compilers.
  6. Forgetting "b" mode for binary files, causing subtle data corruption on some platforms.
  7. Not handling partial reads/writes — fread/fwrite can return fewer items than requested.

15. Real-World Applications

File handling in C powers configuration file parsers, log-writing systems, embedded data loggers, custom database engines and storage formats, image and audio codecs reading/writing binary formats, and command-line tools that process large text files (like custom grep or wc implementations).

16. Interview Questions

17. FAQs

Can I read and write to the same file at the same time? Yes, using modes like "r+" or "w+", but you need to manage the file position indicator carefully between read and write operations.

Why does my program create an empty file even when opening in read mode fails? It shouldn’t — "r" mode never creates a file. If you’re seeing an unexpected empty file, double-check the mode string you’re actually using.

Is fopen thread-safe? The C standard doesn’t guarantee it universally, but most modern platform implementations make individual stream operations safe for concurrent access from different threads on different files; sharing one FILE * across threads without synchronization is still unsafe.

18. Summary and Key Takeaways

File handling in C boils down to a small set of core functions — fopen, fread/fwrite or fscanf/fprintf, fseek, and fclose — but real mastery comes from understanding what’s happening beneath them: buffering, the OS file descriptor layer, text vs. binary distinctions, and disciplined error handling. Get those fundamentals solid, and you can confidently build anything from a simple logger to a custom on-disk data format.

19. References

Exit mobile version