File Handling in C: fopen, fclose, and Reading Files Line by Line

Everything a program computes disappears when it exits, unless it writes it down. C's file interface lives in <stdio.h> - the same header as printf - and it is deliberately similar: a file is a stream of bytes, and the functions that work on the screen have twins that take a stream argument.

The handle type is FILE *. You never look inside a FILE; it is an opaque type (see typedef) and you only ever hold a pointer to one.

The Three Steps

Every file operation follows the same shape: open, use, close.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("greeting.txt", "w");
    if (fp == NULL) {
        fprintf(stderr, "Could not open the file for writing.\n");
        return 1;
    }

    fprintf(fp, "Hello, file!\n");
    fprintf(fp, "Written by a C program.\n");

    fclose(fp);
    printf("Wrote greeting.txt\n");
    return 0;
}

The NULL check is not optional paranoia. fopen fails whenever the file does not exist (in read mode), the directory is not writable, the path is wrong, or the process is out of file handles - and every one of those returns NULL. Using a NULL handle is a segmentation fault.

Sending the error to stderr rather than stdout is the convention: it is unbuffered, and it can be redirected separately from real output.

fopen Modes

The second argument is a short mode string. Getting it wrong is the most destructive mistake in this whole area, because "w" silently empties an existing file.

Append a b to any of these ("rb", "wb", "ab+") for binary mode - more on that at the end.

Two rules that prevent real data loss:

• Use "r" when you mean to read. "r+" on a typo'd filename fails safely; "w+" creates an empty file and you have lost nothing but time. "w" on the right filename when you meant "r" destroys the data.
• Use "a" for logs. Every fprintf lands at the end regardless of where the stream was positioned, which is exactly what a log wants.

Writing and Reading in One Program

The editor below runs a complete round trip - it creates a file, writes records into it, closes it, reopens it for reading, and prints what it finds.

#include <stdio.h>

int main(void) {
    const char *path = "scores.txt";

    /* --- write --- */
    FILE *out = fopen(path, "w");
    if (out == NULL) {
        fprintf(stderr, "cannot open %s for writing\n", path);
        return 1;
    }
    fprintf(out, "Ada %d\n", 92);
    fprintf(out, "Grace %d\n", 105);
    fprintf(out, "Alan %d\n", 87);
    fclose(out);

    /* --- read it back --- */
    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "cannot open %s for reading\n", path);
        return 1;
    }

    char name[32];
    int  score;
    int  total = 0, count = 0;

    while (fscanf(in, "%31s %d", name, &score) == 2) {
        printf("%-8s %3d\n", name, score);
        total += score;
        count++;
    }
    fclose(in);

    if (count > 0) {
        printf("average: %.1f\n", (double)total / count);
    }
    return 0;
}

fprintf and fscanf are printf and scanf with a stream as the first argument; everything about their format specifiers is identical, including the %31s width that keeps name from overflowing.

The loop condition is == 2, the number of items the format asks for. Testing against EOF instead is a classic bug: a malformed line makes fscanf return 0, not EOF, and the loop spins forever on input it cannot consume.

Reading Line by Line with fgets

fscanf is convenient for rigidly formatted data. For text files - configuration, logs, CSV, anything a human wrote - read whole lines. This loop is the canonical one:

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *path = "notes.txt";

    FILE *out = fopen(path, "w");
    if (out == NULL) { return 1; }
    fprintf(out, "first line\n");
    fprintf(out, "second line\n");
    fprintf(out, "third line\n");
    fclose(out);

    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "cannot open %s\n", path);
        return 1;
    }

    char line[256];
    int  lineno = 0;

    while (fgets(line, sizeof line, in) != NULL) {
        line[strcspn(line, "\n")] = '\0';    /* trim the trailing newline */
        lineno++;
        printf("%3d: [%s] (%zu chars)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

What makes fgets the right default:

• It takes the buffer size, so it cannot overflow. Pass sizeof line and the call stays correct if you resize the array.
• It returns NULL at end of file or on error, which is a clean loop condition.
• It keeps the newline when the line fit in the buffer. That is useful - no '\n' in what you got means the line was longer than your buffer and the rest is still waiting. strcspn(line, "\n") finds the newline's index (or the string length if there is none), so assigning '\0' there trims it either way.

To distinguish a real end of file from an error, ask after the loop:

if (ferror(in)) {
    fprintf(stderr, "read error\n");
} else if (feof(in)) {
    /* normal end */
}

Do not write while (!feof(fp)) as a loop condition. feof only becomes true after a read has already failed, so that loop processes the final buffer contents one extra time. Test the return value of the read function instead - as both loops above do.

Character at a Time: fgetc and fputc

For byte-level work - counting characters, transforming a file, copying - fgetc and fputc handle one character per call.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *src = "mixed.txt";
    const char *dst = "upper.txt";

    FILE *out = fopen(src, "w");
    if (out == NULL) { return 1; }
    fputs("Hello there, C programmer!\n", out);
    fclose(out);

    FILE *in = fopen(src, "r");
    FILE *up = fopen(dst, "w");
    if (in == NULL || up == NULL) {
        if (in) fclose(in);
        if (up) fclose(up);
        return 1;
    }

    int c;
    int letters = 0, lines = 0;

    while ((c = fgetc(in)) != EOF) {
        if (isalpha(c)) letters++;
        if (c == '\n')  lines++;
        fputc(toupper(c), up);
    }

    fclose(in);
    fclose(up);

    printf("%d letters, %d lines\n", letters, lines);

    /* show the result */
    FILE *check = fopen(dst, "r");
    if (check != NULL) {
        char line[128];
        while (fgets(line, sizeof line, check) != NULL) {
            printf("%s", line);
        }
        fclose(check);
    }
    return 0;
}

One detail that matters: c is declared int, not char. fgetc returns an int so that it can return every possible byte value and the distinct sentinel EOF (which is -1). Storing it in a char makes the comparison against EOF either always false or falsely true for the byte 0xFF, depending on whether char is signed on your platform. This is one of C's oldest gotchas.

Checking Errors Properly

A production read looks like this:

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main(void) {
    FILE *fp = fopen("does-not-exist.txt", "r");
    if (fp == NULL) {
        fprintf(stderr, "open failed: %s\n", strerror(errno));
        perror("perror says");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno holds a code describing the last failure and strerror turns it into a sentence; perror prints your message plus that sentence in one call. Both need <errno.h> and <string.h> respectively.

fclose can also fail - it flushes buffered data, and the write may not fit on the disk - so for anything important, check it:

if (fclose(fp) != 0) {
    fprintf(stderr, "failed to flush and close\n");
}

Binary Mode in One Paragraph

Text mode may translate line endings (on Windows, \n becomes \r\n when written and back when read) and may treat certain bytes specially. For data that is not text - an image, a struct dumped verbatim, a compressed blob - open with b and use fread/fwrite, which move raw bytes:

#include <stdio.h>

struct Record {
    int    id;
    double value;
};

int main(void) {
    struct Record out[2] = {{1, 3.5}, {2, 7.25}};

    FILE *fp = fopen("records.bin", "wb");
    if (fp == NULL) { return 1; }
    fwrite(out, sizeof out[0], 2, fp);
    fclose(fp);

    struct Record in[2];
    fp = fopen("records.bin", "rb");
    if (fp == NULL) { return 1; }
    size_t got = fread(in, sizeof in[0], 2, fp);
    fclose(fp);

    printf("read %zu records\n", got);
    for (size_t i = 0; i < got; i++) {
        printf("id=%d value=%.2f\n", in[i].id, in[i].value);
    }
    return 0;
}

fwrite(ptr, size, count, fp) writes count items of size bytes and returns how many it managed; fread mirrors it. Be aware that a file written this way is tied to the machine that wrote it - struct padding, integer size, and byte order all leak into the bytes - so it is fine for a cache or scratch file and wrong for a format other programs must read.

Common Mistakes

• Not checking fopen for NULL. The crash that follows is blamed on the read, not the open.
• Opening with "w" when you meant "r". The file is emptied before you notice.
• Forgetting fclose. Buffered output is lost, and each unclosed file leaks a handle.
• while (!feof(fp)). Processes the last line twice. Test the read call instead.
• char c = fgetc(fp). Breaks the EOF comparison. Use int.
• fscanf("%s", buf) with no width. The same buffer overflow as scanf on the keyboard.
• Relative paths. fopen("data.txt", "r") looks in the working directory, not next to the executable. If a file "disappears", that is usually why.