File I/O Operations

Programming Language & Its Applications — Pointers, Structure and Data Files in C, NEC licence examination syllabus (Nepal Engineering Council).

File I/O Operations

Programs that forget everything when they close are toys. Files are how software remembers.

Everything so far has lived in RAM and vanished at return 0. Files give your program persistence. C's model is deliberately simple: open a stream, read or write through it, close it. The FILE* handle you get back hides all the operating-system detail, and the same six functions work on a text file, a device, or a pipe.

🌍 Where this lives: every save button you have ever pressed is this. Your .env file, a CSV export from Excel, the log file that tells a sysadmin why the server crashed at 3 a.m., the SQLite database behind your phone's WhatsApp history — all of them are opened, read, and written with exactly these calls or their equivalents in other languages. When a program says "corrupted file", it usually means someone forgot fclose and the buffer never reached the disk. You are about to learn why that happens.

Opening and closing

#include <stdio.h> FILE *fp = fopen("data.txt", "r"); if (fp == NULL) { perror("fopen"); return 1; } ... fclose(fp); MODES: "r" read — file MUST exist, else NULL "w" write — creates, or TRUNCATES to zero length (!) "a" append — creates, writes always go to the end "r+" read+write — must exist, does not truncate "w+" read+write — creates or truncates "a+" read+append — reads anywhere, writes at the end Add "b" for binary: "rb", "wb", "ab" On Linux/macOS text and binary are identical. On Windows, text mode translates "\n" <-> "\r\n", which CORRUPTS binary data. Always use "b" for non-text. fopen returns NULL on failure. ALWAYS check. Reasons: file absent, no permission, path wrong, too many open files, disk full (for write modes).

"w" destroys the file's contents the instant you open it — before you write a single byte. Opening a file you meant to read with the wrong mode letter is how people lose data. If you want to add to a file, the mode is "a".

The four ways to read and write

CHARACTER at a time int fgetc(FILE *fp); returns EOF at end int fputc(int c, FILE *fp); LINE at a time (preferred for text) char *fgets(char *buf, int size, FILE *fp); NULL at end int fputs(const char *s, FILE *fp); FORMATTED (like printf/scanf) int fprintf(FILE *fp, "fmt", ...); int fscanf (FILE *fp, "fmt", ...); returns items matched BLOCK / BINARY (whole structs at once) size_t fwrite(const void *p, size_t sz, size_t n, FILE *fp); size_t fread (void *p, size_t sz, size_t n, FILE *fp); → both return the NUMBER OF ITEMS transferred Note fgetc returns int, not char — because EOF is −1 and must be distinguishable from the valid byte 0xFF.

textfile.c

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

int main(void) {
    /* WRITE */
    FILE *fp = fopen("marks.txt", "w");
    if (!fp) { perror("marks.txt"); return 1; }
    fprintf(fp, "101 Ram    87.5\n");
    fprintf(fp, "102 Sita   91.0\n");
    fprintf(fp, "103 Hari   76.5\n");
    fclose(fp);        /* flushes the buffer to disk */

    /* APPEND - does not destroy what is there */
    fp = fopen("marks.txt", "a");
    fprintf(fp, "104 Gita   68.0\n");
    fclose(fp);

    /* READ line by line */
    fp = fopen("marks.txt", "r");
    if (!fp) return 1;
    char line[128];
    int lines = 0;
    printf("--- fgets ---\n");
    while (fgets(line, sizeof line, fp)) {
        line[strcspn(line, "\n")] = '\0';
        printf("%2d | %s\n", ++lines, line);
    }

    /* READ with fscanf into variables */
    rewind(fp);                /* back to the start */
    printf("--- fscanf ---\n");
    int roll; char name[20]; float m; float total = 0; int n = 0;
    while (fscanf(fp, "%d %19s %f", &roll, name, &m) == 3) {
        printf("%d %-8s %.1f\n", roll, name, m);
        total += m; n++;
    }
    printf("average = %.2f over %d records\n", total/n, n);
    fclose(fp);
    return 0;
}
Output:
--- fgets ---
 1 | 101 Ram    87.5
 2 | 102 Sita   91.0
 3 | 103 Hari   76.5
 4 | 104 Gita   68.0
--- fscanf ---
101 Ram      87.5
102 Sita     91.0
103 Hari     76.5
104 Gita     68.0
average = 80.75 over 4 records

Checking: (87.5 + 91.0 + 76.5 + 68.0) / 4 = 323.0 / 4 = 80.75 ✔ Note the "%19s" not "%s" in fscanf — name holds 20 bytes, so at most 19 characters plus the terminator. Bare "%s" would happily overflow it. Same lesson as scanf.

Worked example 1 — copying a file, and counting it

copycount.c

#include <stdio.h>

int main(void) {
    FILE *in = fopen("marks.txt", "r");
    if (!in) { perror("open in"); return 1; }
    FILE *out = fopen("copy.txt", "w");
    if (!out) { perror("open out"); fclose(in); return 1; }

    long chars = 0, lines = 0, words = 0;
    int c, in_word = 0;

    while ((c = fgetc(in)) != EOF) {   /* note: int c */
        fputc(c, out);
        chars++;
        if (c == '\n') lines++;
        if (c == ' ' || c == '\n' || c == '\t') in_word = 0;
        else if (!in_word) { in_word = 1; words++; }
    }
    fclose(in); fclose(out);

    printf("chars=%ld words=%ld lines=%ld\n",
           chars, words, lines);
    return 0;
}
Output:
chars=76 words=12 lines=4

That int c matters. Declare it char c and on a platform where char is unsigned, c != EOF is always true — the loop never ends. Where char is signed, a legitimate byte 0xFF reads as −1 and the loop stops early, truncating your copy. This is the same trap as in the unformatted-I/O topic, and it is the kind of bug that only shows up on someone else's machine.

Worked example 2 — binary I/O with structs

binary.c

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

typedef struct {
    int   roll;
    char  name[20];
    float marks;
} Student;                    /* 28 bytes */

int main(void) {
    Student in[3] = {
        {101, "Ram Bahadur",  87.5f},
        {102, "Sita Devi",    91.0f},
        {103, "Hari Prasad",  76.5f}
    };

    /* write all three in ONE call */
    FILE *fp = fopen("students.dat", "wb");
    if (!fp) return 1;
    size_t w = fwrite(in, sizeof(Student), 3, fp);
    printf("wrote %zu records (%zu bytes)\n",
           w, w * sizeof(Student));
    fclose(fp);

    /* read them back */
    Student out[3];
    fp = fopen("students.dat", "rb");
    size_t r = fread(out, sizeof(Student), 3, fp);
    printf("read  %zu records\n", r);
    for (size_t i = 0; i < r; i++)
        printf("  %d %-14s %.1f\n",
               out[i].roll, out[i].name, out[i].marks);

    /* file size from the stream */
    fseek(fp, 0, SEEK_END);
    printf("file size = %ld bytes = %ld records\n",
           ftell(fp), ftell(fp)/(long)sizeof(Student));
    fclose(fp);
    return 0;
}
Output:
wrote 3 records (84 bytes)
read  3 records
  101 Ram Bahadur    87.5
  102 Sita Devi      91.0
  103 Hari Prasad    76.5
file size = 84 bytes = 3 records

Text vs binary for the same 3 records: TEXT "101 Ram Bahadur 87.5\n" ≈ 22 bytes × 3 = 66 bytes + must be PARSED on read (fscanf must convert "87.5" from 4 characters into a float) + human-readable, greppable, diffable + portable across every machine BINARY 28 bytes × 3 = 84 bytes + no parsing: the bytes ARE the struct + fixed size per record → random access by multiplying (see the next topic) − unreadable in a text editor − NOT portable: depends on padding, endianness, and sizeof(int) on the writing machine So a file written by binary fwrite on a 64-bit little-endian Linux box may be unreadable on a different architecture. Real formats (JSON, Protocol Buffers, SQLite) solve this by specifying the byte layout explicitly.

Buffering — why fclose matters

Writes do not go straight to the disk. They accumulate in a buffer (typically 4 KB) and are flushed when: · the buffer fills · fflush(fp) is called · fclose(fp) is called · the program exits NORMALLY (via return from main/exit) Why buffer at all? A disk write is roughly 100,000× slower than a memory write. Batching 4096 one-byte writes into one 4 KB write turns 4096 slow operations into one. The consequence: if your program CRASHES before fclose, the buffered data is LOST — the file looks truncated or empty even though your printf statements "worked". fp = fopen("log.txt","w"); fprintf(fp, "important\n"); abort(); ← "important" never reaches disk Fix: fclose when done, or fflush at critical points. This is exactly why crash logs are often incomplete.

buffering.c

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("log.txt", "w");
    if (!fp) return 1;

    fprintf(fp, "step 1 done\n");
    /* at this instant log.txt is still EMPTY on disk */

    fflush(fp);      /* force it out NOW */
    /* now a crash would still preserve step 1 */

    fprintf(fp, "step 2 done\n");
    fclose(fp);      /* flush + release the handle */

    /* forgetting fclose leaks a file descriptor.
       A long-running server that leaks them eventually
       fails with "Too many open files" (EMFILE). */
    return 0;
}
Output: (no console output; check log.txt)
step 1 done
step 2 done

🌍 Go further: the buffering above is only half the story — fclose hands your bytes to the operating system, but the OS has its own page cache and may still not have touched the physical disk. That is what fsync() is for, and it is why databases are slower than you expect: PostgreSQL must fsync its write-ahead log before it can honestly say "transaction committed". Search for "fsync and the write-ahead log" if you want to see how a real database turns this one system call into a durability guarantee.

💡 Exam angle: the mode table is asked directly — in particular that "w" truncates and "a" appends. Always show the if (fp == NULL) check; marks are lost for omitting it. Standard programs: copy a file, count characters/words/lines, write and read a student record file. Know that fgetc returns int because of EOF, that fwrite/fread return an item count, and be ready to compare text vs binary files on size, portability and parsing cost.

Syllabus points

fopen, fclose, fprintf, fscanf, fread, fwrite

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.