← File I/O (ANSI C)

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

What are the different fopen() modes and when do you use each?

fopen(const char *path, const char *mode) opens a file and returns a FILE * stream. The mode string controls read/write access and how the file is created or truncated.

Text modes:

Mode	Description	File exists	File missing
`"r"`	Read only	Opens	Returns NULL
`"w"`	Write only (truncates)	Truncates to 0	Creates new
`"a"`	Append only	Appends at end	Creates new
`"r+"`	Read + write	Opens	Returns NULL
`"w+"`	Read + write (truncates)	Truncates to 0	Creates new
`"a+"`	Read + append	Opens (writes at end)	Creates new

Binary modes: Add b to any mode: "rb", "wb", "ab", "r+b" (or "rb+"), etc.

On Unix/Linux: binary and text modes are identical
On Windows: text mode translates \n to \r\n and treats Ctrl+Z as EOF; binary mode does not

C11 exclusive mode: "wx", "wbx" -- fails if file already exists (prevents accidental overwrite). Like O_CREAT | O_EXCL in POSIX.

Critical rule: Always check the return value for NULL.

Pseudo Code

Read existing file:      fopen("data.txt", "r")
Create/overwrite file:   fopen("data.txt", "w")
Append to file:          fopen("data.txt", "a")
Read + write existing:   fopen("data.txt", "r+")
Create + read/write:     fopen("data.txt", "w+")
Binary read:             fopen("data.bin", "rb")
Binary write:            fopen("data.bin", "wb")
Exclusive create (C11):  fopen("data.txt", "wx")

Code

#include <stdio.h>

int main(void) {
    FILE *fp;

    /* Write mode: creates or truncates */
    fp = fopen("test.txt", "w");
    if (!fp) { perror("fopen w"); return 1; }
    fprintf(fp, "Line 1\n");
    fprintf(fp, "Line 2\n");
    fclose(fp);

    /* Append mode: adds to end */
    fp = fopen("test.txt", "a");
    if (!fp) { perror("fopen a"); return 1; }
    fprintf(fp, "Line 3\n");
    fclose(fp);

    /* Read mode: reads existing */
    fp = fopen("test.txt", "r");
    if (!fp) { perror("fopen r"); return 1; }
    char buf[100];
    while (fgets(buf, sizeof(buf), fp)) {
        printf("%s", buf);
    }
    /* Output: Line 1\nLine 2\nLine 3 */
    fclose(fp);

    /* Read+Write mode */
    fp = fopen("test.txt", "r+");
    if (!fp) { perror("fopen r+"); return 1; }
    fprintf(fp, "MODIFIED"); /* overwrites first 8 bytes */
    fclose(fp);

    /* Binary mode */
    fp = fopen("data.bin", "wb");
    if (!fp) { perror("fopen wb"); return 1; }
    int nums[] = {1, 2, 3, 4, 5};
    fwrite(nums, sizeof(int), 5, fp);
    fclose(fp);

    /* Cleanup */
    remove("test.txt");
    remove("data.bin");

    printf("All modes demonstrated successfully\n");
    return 0;
}

Key Points

•"r" reads existing; "w" creates/truncates; "a" appends; + adds the other direction
•Always check fopen return for NULL before using the FILE pointer
•Binary mode ("rb"/"wb") matters on Windows (no \r\n translation)
•On Unix, binary and text modes are identical
•"wx" (C11) fails if file exists -- prevents accidental overwrite

Gotchas

•"w" destroys existing file contents immediately on open -- there is no undo
•"a" mode always writes at end, even after fseek -- you cannot overwrite earlier content
•Forgetting to check fopen return for NULL leads to NULL pointer dereference crash
•On Windows, reading binary files in text mode corrupts data (\r\n translation and Ctrl+Z EOF)

"r" reads, "w" writes (truncates), "a" appends. Add + for read+write, b for binary. Always check for NULL. "w" destroys existing content on open.

•r=read, w=write(truncate), a=append, +=both, b=binary
•Always check fopen return for NULL

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("demo.txt", "w");
    if (!fp) { perror("fopen"); return 1; }
    fprintf(fp, "Hello\n");
    fclose(fp);

    fp = fopen("demo.txt", "r");
    if (!fp) { perror("fopen"); return 1; }
    char buf[64];
    while (fgets(buf, sizeof(buf), fp))
        printf("%s", buf);
    fclose(fp);
    remove("demo.txt");
    return 0;
}

Hello

"w" destroys existing file contents immediately

Question 2 / 12

Why is fclose() important and what happens if you forget it?

fclose(FILE *fp) flushes the stream's buffer, releases the FILE object, and closes the underlying file descriptor.

What fclose does:

Flushes write buffers -- ensures all data is written to disk
Releases the FILE structure memory
Closes the file descriptor (returns it to the OS)
Returns 0 on success, EOF on error

What happens if you forget fclose:

Data loss: Buffered writes may never reach disk (data sitting in userspace buffer)
File descriptor leak: OS has a per-process limit (typically 1024 by default). Opening files without closing eventually causes fopen to fail with EMFILE.
Resource exhaustion: Long-running programs (servers) accumulate leaked descriptors
On normal exit: The C runtime calls fclose on all open streams during exit(), so data is usually flushed. But abnormal termination (crash, _exit(), abort()) skips this.

Best practices:

Close files as soon as you are done with them
Check fclose return value for write streams (write errors detected at flush time)
Use a consistent pattern: open, use, close in the same scope

Pseudo Code

Proper pattern:
  FILE *fp = fopen("file.txt", "w");
  if (!fp) { handle_error(); }
  /* write to fp */
  if (fclose(fp) != 0) {
      perror("fclose");  /* write error detected at flush */
  }

What fclose does internally:
  1. fflush(fp)      -- write buffer to kernel
  2. close(fd)        -- release file descriptor
  3. free(fp)         -- release FILE struct

Forgetting fclose:
  - Buffered data may be lost on crash
  - File descriptors accumulate until limit (EMFILE)

Code

#include <stdio.h>

int main(void) {
    /* Always check fclose return on write streams */
    FILE *fp = fopen("output.txt", "w");
    if (!fp) {
        perror("fopen");
        return 1;
    }

    fprintf(fp, "Important data\n");

    /* fclose flushes buffer and returns 0 on success */
    if (fclose(fp) != 0) {
        perror("fclose"); /* disk full, I/O error, etc. */
        return 1;
    }
    /* fp is now invalid -- do not use it */

    /* Demonstrate: open many files without closing */
    int count = 0;
    for (int i = 0; i < 2000; i++) {
        FILE *f = fopen("output.txt", "r");
        if (!f) {
            printf("Failed to open at iteration %d\n", i);
            break;
        }
        count++;
        /* intentionally NOT closing -- fd leak! */
        /* In real code: fclose(f); */
    }
    printf("Opened %d files before exhaustion\n", count);
    /* Process now has ~count leaked file descriptors */

    remove("output.txt");
    return 0;
}

Failed to open at iteration <N>
Opened <N> files before exhaustion
(Note: <N> is platform-dependent; typically ~253 on macOS, ~1021 on Linux)

Key Points

•fclose flushes buffers, closes the file descriptor, and frees the FILE struct
•Forgetting fclose risks data loss (unflushed buffers) and file descriptor exhaustion
•Always check fclose return value on write streams -- errors may only appear at flush time
•exit() calls fclose on all open streams, but crash/abort/_exit do not
•Per-process file descriptor limit is typically 1024 (ulimit -n)

Gotchas

•fclose on a NULL pointer is undefined behavior -- always check fopen's return first
•Double-fclose is undefined behavior, like double-free
•Write errors (disk full) may only be reported by fclose, not by fprintf/fwrite
•On crash or _exit(), buffered data is lost because fclose is never called

fclose() flushes buffers and releases the file descriptor. Without it: data loss (unflushed writes), file descriptor exhaustion. Always check its return on write streams.

•fclose flushes and releases resources; check return on write streams
•Forgetting fclose leaks file descriptors

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("out.txt", "w");
    if (!fp) { perror("fopen"); return 1; }
    fprintf(fp, "data\n");
    if (fclose(fp) != 0) { /* check for write errors */
        perror("fclose");
        return 1;
    }
    remove("out.txt");
    return 0;
}

Double-fclose is undefined behavior

Question 3 / 12

How do fread() and fwrite() work for binary I/O?

fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) Writes nmemb elements of size bytes each from ptr to the stream. Returns the number of elements successfully written.

fread(void *ptr, size_t size, size_t nmemb, FILE *stream) Reads up to nmemb elements of size bytes each into ptr. Returns the number of elements successfully read.

Parameters:

ptr -- buffer to write from / read into
size -- size of each element in bytes
nmemb -- number of elements
stream -- FILE pointer opened in binary mode

Return value: The number of elements (not bytes) successfully transferred. Check this against nmemb to detect short reads/writes. On error or EOF, it is less than nmemb.

Use cases:

Serializing structs/arrays to files
Reading/writing binary file formats (BMP, WAV headers)
Bulk data transfer (faster than character-by-character)

Important: Data written with fwrite is not portable across architectures (endianness, padding, pointer sizes differ).

Pseudo Code

Write array to binary file:
  FILE *fp = fopen("data.bin", "wb");
  int arr[5] = {1,2,3,4,5};
  size_t written = fwrite(arr, sizeof(int), 5, fp);
  if (written != 5) handle_error();
  fclose(fp);

Read array from binary file:
  FILE *fp = fopen("data.bin", "rb");
  int arr[5];
  size_t read = fread(arr, sizeof(int), 5, fp);
  if (read != 5) handle_error();
  fclose(fp);

Code

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

typedef struct {
    char name[32];
    int age;
    double gpa;
} Student;

int main(void) {
    /* Write binary data */
    Student students[] = {
        {"Alice", 20, 3.8},
        {"Bob", 22, 3.5},
        {"Charlie", 21, 3.9}
    };
    int n = sizeof(students) / sizeof(students[0]);

    FILE *fp = fopen("students.bin", "wb");
    if (!fp) { perror("fopen wb"); return 1; }

    /* Write count first, then array */
    fwrite(&n, sizeof(int), 1, fp);
    size_t written = fwrite(students, sizeof(Student), n, fp);
    if ((int)written != n) {
        fprintf(stderr, "Write error: only %zu of %d\n", written, n);
    }
    fclose(fp);

    /* Read binary data back */
    fp = fopen("students.bin", "rb");
    if (!fp) { perror("fopen rb"); return 1; }

    int count;
    fread(&count, sizeof(int), 1, fp);
    printf("Reading %d students:\n", count);

    Student buf[10];
    size_t nread = fread(buf, sizeof(Student), count, fp);
    fclose(fp);

    for (size_t i = 0; i < nread; i++) {
        printf("  %s, age %d, GPA %.1f\n",
               buf[i].name, buf[i].age, buf[i].gpa);
    }

    /* Write/read raw integer array */
    fp = fopen("ints.bin", "wb");
    if (fp) {
        int arr[] = {10, 20, 30, 40, 50};
        fwrite(arr, sizeof(int), 5, fp);
        fclose(fp);
    }

    fp = fopen("ints.bin", "rb");
    if (fp) {
        int arr[5];
        fread(arr, sizeof(int), 5, fp);
        printf("Ints: %d %d %d %d %d\n",
               arr[0], arr[1], arr[2], arr[3], arr[4]);
        fclose(fp);
    }

    remove("students.bin");
    remove("ints.bin");
    return 0;
}

Reading 3 students:
  Alice, age 20, GPA 3.8
  Bob, age 22, GPA 3.5
  Charlie, age 21, GPA 3.9
Ints: 10 20 30 40 50

Key Points

•fwrite/fread transfer blocks of binary data; return element count, not byte count
•Always check return value against expected nmemb to detect short reads/writes
•Open files in binary mode ("wb"/"rb") for binary I/O
•fwrite/fread can serialize entire arrays and structs in one call
•Binary files are NOT portable across architectures (endianness, padding)

Gotchas

•fread/fwrite return element count, not byte count -- misinterpreting this is a common bug
•Binary files written on one platform may not be readable on another (endianness, struct padding)
•Using text mode for binary I/O corrupts data on Windows (\n <-> \r\n translation)
•fread does not distinguish between EOF and error -- use feof() and ferror() to check

fwrite(buf, elem_size, count, fp) writes binary data; fread(buf, elem_size, count, fp) reads it. Return value is the number of elements transferred. Open in binary mode ("wb"/"rb").

•Return value is element count, not byte count
•Use binary mode ("rb"/"wb") for binary data

#include <stdio.h>

int main(void) {
    int arr[] = {10, 20, 30};
    FILE *fp = fopen("data.bin", "wb");
    fwrite(arr, sizeof(int), 3, fp);
    fclose(fp);

    int buf[3];
    fp = fopen("data.bin", "rb");
    size_t n = fread(buf, sizeof(int), 3, fp);
    fclose(fp);
    printf("Read %zu: %d %d %d\n", n, buf[0], buf[1], buf[2]);
    remove("data.bin");
    return 0;
}

Read 3: 10 20 30

Binary files are not portable across architectures

Question 4 / 12

How do fprintf() and fscanf() work for formatted file I/O?

fprintf(FILE *stream, const char *format, ...) writes formatted text to a file stream. Same format specifiers as printf but writes to any FILE* instead of stdout.

fscanf(FILE *stream, const char *format, ...) reads formatted input from a file stream. Same format specifiers as scanf but reads from any FILE*.

fprintf returns the number of characters written, or a negative value on error.

fscanf returns the number of input items successfully matched, or EOF on input failure before any matching.

Common format specifiers:

%d -- int, %ld -- long, %f -- float, %lf -- double
%s -- string (word), %c -- char, %zu -- size_t
%[^\n] -- read until newline (like fgets but with scanf)

fprintf vs fwrite: fprintf produces human-readable text; fwrite produces binary. Text files are portable but slower and larger. Binary is fast and compact but not portable.

Pseudo Code

Write formatted data:
  fprintf(fp, "Name: %s, Age: %d, GPA: %.2f\n", name, age, gpa);

Read formatted data:
  int n = fscanf(fp, "%s %d %lf", name, &age, &gpa);
  if (n != 3) handle_error();

fprintf returns: characters written (or negative on error)
fscanf returns: items matched (or EOF on end/error)

Code

#include <stdio.h>

typedef struct {
    char name[50];
    int age;
    double gpa;
} Student;

int main(void) {
    /* Write formatted text file */
    Student data[] = {
        {"Alice", 20, 3.80},
        {"Bob", 22, 3.50},
        {"Charlie", 21, 3.95}
    };
    int n = 3;

    FILE *fp = fopen("students.csv", "w");
    if (!fp) { perror("fopen"); return 1; }

    fprintf(fp, "name,age,gpa\n"); /* header */
    for (int i = 0; i < n; i++) {
        fprintf(fp, "%s,%d,%.2f\n",
                data[i].name, data[i].age, data[i].gpa);
    }
    fclose(fp);

    /* Read formatted text file */
    fp = fopen("students.csv", "r");
    if (!fp) { perror("fopen"); return 1; }

    char header[100];
    fgets(header, sizeof(header), fp); /* skip header */

    Student buf;
    printf("Students:\n");
    while (fscanf(fp, "%[^,],%d,%lf\n",
                  buf.name, &buf.age, &buf.gpa) == 3) {
        printf("  %s (age %d) GPA=%.2f\n",
               buf.name, buf.age, buf.gpa);
    }
    fclose(fp);

    /* fprintf to stderr (diagnostic output) */
    fprintf(stderr, "Processing complete\n");

    remove("students.csv");
    return 0;
}

Students:
  Alice (age 20) GPA=3.80
  Bob (age 22) GPA=3.50
  Charlie (age 21) GPA=3.95

Key Points

•fprintf writes formatted text to any FILE*; fscanf reads formatted input
•Same format specifiers as printf/scanf
•fprintf returns character count; fscanf returns matched item count
•Always check fscanf return to detect parsing failures
•Text format is portable but larger/slower than binary

Gotchas

•fscanf %s stops at whitespace -- cannot read strings with spaces
•fscanf does not consume the trailing newline by default -- can cause issues with subsequent reads
•Buffer overflow: fscanf %s has no length limit -- use %49s for a 50-char buffer
•fprintf to a full disk may silently fail -- check return value or fclose return

fprintf(fp, fmt, ...) writes formatted text; fscanf(fp, fmt, ...) reads it. Same specifiers as printf/scanf. Check fscanf return for matched item count.

•fprintf/fscanf: formatted text I/O to files
•Always check fscanf return value

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("data.txt", "w");
    fprintf(fp, "%s %d %.2f\n", "Alice", 20, 3.8);
    fclose(fp);

    fp = fopen("data.txt", "r");
    char name[50]; int age; double gpa;
    if (fscanf(fp, "%49s %d %lf", name, &age, &gpa) == 3)
        printf("%s age=%d gpa=%.2f\n", name, age, gpa);
    fclose(fp);
    remove("data.txt");
    return 0;
}

Alice age=20 gpa=3.80

fscanf %s has no length limit -- always specify width like %49s

Question 5 / 12

How do you safely read lines from a file using fgets()?

fgets(char *buf, int n, FILE *stream) reads at most n-1 characters from the stream into buf, stopping at a newline or EOF. It always null-terminates the buffer.

Returns: buf on success, NULL on EOF or error.

Why fgets, not gets: gets() was removed from C11 because it has no buffer size parameter -- guaranteed buffer overflow vulnerability. fgets() is the safe replacement.

Behavior details:

Reads up to n-1 chars (reserves 1 for \0)
Includes the \n in the buffer if the line fits
If the line is longer than n-1, the \n is NOT included (line was truncated)
Returns NULL at EOF (or error)

Removing the trailing newline:

buf[strcspn(buf, "\n")] = '\0';

This is the safest one-liner to strip the newline.

Pseudo Code

Read all lines from a file:
  char buf[256];
  while (fgets(buf, sizeof(buf), fp) != NULL) {
      buf[strcspn(buf, "\n")] = '\0';  /* strip newline */
      process(buf);
  }

fgets behavior:
  Buffer size 10, line "Hello\n":
    buf = "Hello\n\0"  (7 chars + null)
  Buffer size 4, line "Hello\n":
    buf = "Hel\0"  (3 chars + null, line truncated)
    Next fgets: buf = "lo\n\0"

Code

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

int main(void) {
    /* Create a test file */
    FILE *fp = fopen("lines.txt", "w");
    if (!fp) { perror("fopen"); return 1; }
    fprintf(fp, "First line\n");
    fprintf(fp, "Second line\n");
    fprintf(fp, "Third line with no trailing newline");
    fclose(fp);

    /* Read lines safely with fgets */
    fp = fopen("lines.txt", "r");
    if (!fp) { perror("fopen"); return 1; }

    char buf[256];
    int line_num = 0;
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        line_num++;
        /* Remove trailing newline if present */
        buf[strcspn(buf, "\n")] = '\0';
        printf("Line %d: [%s]\n", line_num, buf);
    }
    fclose(fp);

    /* Demonstrating truncation with small buffer */
    fp = fopen("lines.txt", "r");
    if (!fp) { perror("fopen"); return 1; }

    char small[8]; /* small buffer */
    printf("\nSmall buffer reads:\n");
    while (fgets(small, sizeof(small), fp) != NULL) {
        printf("  [%s]\n", small);
        /* Long lines are read in multiple chunks */
    }
    fclose(fp);

    /* NEVER use gets() -- removed from C11 */
    /* char buf[100]; gets(buf); -- BUFFER OVERFLOW! */

    /* Safe stdin reading with fgets */
    /* printf("Enter name: ");
    if (fgets(buf, sizeof(buf), stdin)) {
        buf[strcspn(buf, "\n")] = '\0';
        printf("Hello, %s!\n", buf);
    } */

    remove("lines.txt");
    return 0;
}

Line 1: [First line]
Line 2: [Second line]
Line 3: [Third line with no trailing newline]

Small buffer reads:
  [First l]
  [ine
]
  [Second ]
  [line
]
  [Third l]
  [ine wit]
  [h no tr]
  [ailing ]
  [newline]

Key Points

•fgets reads at most n-1 chars and always null-terminates
•Includes the newline in buffer if line fits; omits it if truncated
•Returns NULL at EOF or error -- use as loop condition
•Strip newline with buf[strcspn(buf, "\n")] = '\0'
•gets() was removed from C11 -- never use it

Gotchas

•fgets includes the \n character -- you must strip it yourself
•If the line does not fit in the buffer, fgets returns a partial line (no \n at end)
•fgets returns NULL on both EOF and error -- use feof/ferror to distinguish
•The size parameter is int (not size_t) -- passing INT_MAX+1 is undefined

fgets(buf, size, fp) reads up to size-1 chars, null-terminates, includes \n. Returns NULL at EOF. Strip newline with buf[strcspn(buf, "\n")] = '\0';. Never use gets().

•Reads up to n-1 chars with null termination; includes \n
•Strip newline with strcspn; never use gets()

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

int main(void) {
    FILE *fp = fopen("test.txt", "w");
    fprintf(fp, "Hello World\n");
    fclose(fp);

    fp = fopen("test.txt", "r");
    char buf[64];
    while (fgets(buf, sizeof(buf), fp)) {
        buf[strcspn(buf, "\n")] = '\0';
        printf("[%s]\n", buf); /* [Hello World] */
    }
    fclose(fp);
    remove("test.txt");
    return 0;
}

[Hello World]

fgets includes the \n -- always strip it if you do not want it

Question 6 / 12

How do fseek(), ftell(), and rewind() work for random file access?

Random access functions let you move the file position indicator to arbitrary locations instead of reading/writing sequentially.

fseek(FILE *fp, long offset, int whence) Moves the file position. Returns 0 on success, nonzero on error.

SEEK_SET -- offset from beginning of file
SEEK_CUR -- offset from current position
SEEK_END -- offset from end of file

ftell(FILE *fp) Returns the current file position as a long, or -1L on error.

rewind(FILE *fp) Equivalent to fseek(fp, 0, SEEK_SET) but also clears the error indicator. Returns void (cannot fail).

For large files (>2GB): Use fseeko/ftello with off_t type, or the C99 fgetpos/fsetpos with fpos_t.

Common patterns:

Get file size: fseek(fp, 0, SEEK_END); long size = ftell(fp); rewind(fp);
Skip N bytes: fseek(fp, N, SEEK_CUR);
Read from specific offset: fseek(fp, offset, SEEK_SET); fread(...);

Pseudo Code

Get file size:
  fseek(fp, 0, SEEK_END);  /* go to end */
  long size = ftell(fp);    /* position = file size */
  rewind(fp);               /* go back to start */

Read record N from binary file:
  fseek(fp, N * sizeof(record), SEEK_SET);
  fread(&record, sizeof(record), 1, fp);

Append then re-read:
  fseek(fp, 0, SEEK_END);  /* go to end */
  fwrite(data, ...);
  rewind(fp);               /* back to start */
  fread(buf, ...);          /* read from beginning */

Code

#include <stdio.h>

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

int main(void) {
    /* Create a binary file with records */
    FILE *fp = fopen("records.bin", "w+b");
    if (!fp) { perror("fopen"); return 1; }

    Record records[] = {
        {1, "Alice"}, {2, "Bob"}, {3, "Charlie"}, {4, "Diana"}
    };
    fwrite(records, sizeof(Record), 4, fp);

    /* Get file size using fseek + ftell */
    fseek(fp, 0, SEEK_END);
    long file_size = ftell(fp);
    printf("File size: %ld bytes\n", file_size);
    printf("Records: %ld\n", file_size / (long)sizeof(Record));

    /* Random access: read record #2 (index 2) directly */
    fseek(fp, 2 * sizeof(Record), SEEK_SET);
    Record r;
    fread(&r, sizeof(Record), 1, fp);
    printf("Record 2: id=%d name=%s\n", r.id, r.name); /* Charlie */

    /* Read record #0 */
    rewind(fp); /* same as fseek(fp, 0, SEEK_SET) + clear error */
    fread(&r, sizeof(Record), 1, fp);
    printf("Record 0: id=%d name=%s\n", r.id, r.name); /* Alice */

    /* Move relative to current position */
    fseek(fp, sizeof(Record), SEEK_CUR); /* skip one record */
    long pos = ftell(fp);
    printf("Current position: %ld (record index %ld)\n",
           pos, pos / (long)sizeof(Record)); /* record 2 */

    /* Update a specific record in place */
    Record updated = {2, "Robert"};
    fseek(fp, 1 * sizeof(Record), SEEK_SET);
    fwrite(&updated, sizeof(Record), 1, fp);

    /* Verify update */
    fseek(fp, 1 * sizeof(Record), SEEK_SET);
    fread(&r, sizeof(Record), 1, fp);
    printf("Updated record 1: id=%d name=%s\n", r.id, r.name); /* Robert */

    fclose(fp);
    remove("records.bin");
    return 0;
}

File size: 96 bytes
Records: 4
Record 2: id=3 name=Charlie
Record 0: id=1 name=Alice
Current position: 48 (record index 2)
Updated record 1: id=2 name=Robert

Key Points

•fseek moves position: SEEK_SET (absolute), SEEK_CUR (relative), SEEK_END (from end)
•ftell returns current position as long; -1L on error
•rewind = fseek(fp, 0, SEEK_SET) + clear error indicator
•File size pattern: fseek to end, ftell, rewind
•Binary random access: fseek(fp, index * sizeof(record), SEEK_SET)

Gotchas

•ftell returns long -- files >2GB overflow on 32-bit systems; use fgetpos/fsetpos or fseeko/ftello
•fseek on text streams: only fseek(fp, 0, SEEK_SET) and fseek(fp, ftell_value, SEEK_SET) are portable
•fseek with SEEK_END on binary streams is not guaranteed by the C standard (but works on POSIX)
•After switching between read and write on r+/w+ streams, fseek or fflush is required

fseek(fp, offset, SEEK_SET/CUR/END) positions the file. ftell(fp) returns position. rewind(fp) resets to start. File size: seek to end, ftell, rewind.

•SEEK_SET=absolute, SEEK_CUR=relative, SEEK_END=from end
•File size: fseek end + ftell

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("test.bin", "w+b");
    int arr[] = {10, 20, 30};
    fwrite(arr, sizeof(int), 3, fp);

    fseek(fp, 0, SEEK_END);
    printf("Size: %ld\n", ftell(fp)); /* 12 */

    fseek(fp, sizeof(int), SEEK_SET); /* seek to 2nd element */
    int val;
    fread(&val, sizeof(int), 1, fp);
    printf("val: %d\n", val); /* 20 */

    fclose(fp);
    remove("test.bin");
    return 0;
}

Size: 12
val: 20

ftell uses long -- overflows for files >2GB on 32-bit systems

Question 7 / 12

What are the pitfalls of feof() for EOF detection?

The #1 C file I/O mistake: Using feof() to control a read loop.

Why while (!feof(fp)) is wrong: feof() returns true only after a read operation has already failed due to EOF. It does not predict the next read. This means:

The last successful read fills the buffer
feof() is still false (EOF not yet encountered)
The loop executes one more iteration
The next read fails (now at EOF)
Code processes stale data from the previous read
Then feof() becomes true and the loop exits

Result: The last item is processed twice.

Correct patterns:

while (fgets(buf, sizeof(buf), fp) != NULL) { ... }
while (fread(&rec, sizeof(rec), 1, fp) == 1) { ... }
while (fscanf(fp, "%d", &val) == 1) { ... }
int ch; while ((ch = fgetc(fp)) != EOF) { ... }

When feof IS useful: After a read loop exits, to distinguish between EOF (normal) and error (abnormal):

if (feof(fp)) printf("End of file\n");
else if (ferror(fp)) printf("Read error\n");

Pseudo Code

WRONG:
  while (!feof(fp)) {
      fread(&data, sizeof(data), 1, fp);
      process(data);  /* BUG: processes stale data on last iteration */
  }

CORRECT:
  while (fread(&data, sizeof(data), 1, fp) == 1) {
      process(data);  /* only processes successful reads */
  }
  /* After loop: check why it ended */
  if (ferror(fp)) handle_error();
  /* else: normal EOF */

Code

#include <stdio.h>

int main(void) {
    /* Create test file */
    FILE *fp = fopen("nums.txt", "w");
    fprintf(fp, "10 20 30");
    fclose(fp);

    /* WRONG: while (!feof(fp)) -- processes last value twice */
    printf("WRONG approach:\n");
    fp = fopen("nums.txt", "r");
    int val;
    while (!feof(fp)) {
        fscanf(fp, "%d", &val);
        printf("  read: %d\n", val);
    }
    fclose(fp);
    /* Output: 10, 20, 30, 30 (30 appears twice!) */

    /* CORRECT: check fscanf return value */
    printf("CORRECT approach:\n");
    fp = fopen("nums.txt", "r");
    while (fscanf(fp, "%d", &val) == 1) {
        printf("  read: %d\n", val);
    }
    /* Distinguish EOF from error */
    if (feof(fp)) {
        printf("  (reached end of file)\n");
    } else if (ferror(fp)) {
        printf("  (read error occurred)\n");
    }
    fclose(fp);
    /* Output: 10, 20, 30 (correct!) */

    /* CORRECT: fgets pattern */
    printf("fgets approach:\n");
    fp = fopen("nums.txt", "r");
    char buf[100];
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        printf("  line: [%s]\n", buf);
    }
    fclose(fp);

    remove("nums.txt");
    return 0;
}

Key Points

•while (!feof(fp)) is almost always wrong -- processes last item twice
•feof returns true only AFTER a read has already failed
•Correct: use the read function's return value as the loop condition
•feof is useful AFTER the loop to distinguish EOF from error
•ferror() checks for read/write errors (as opposed to normal EOF)

Gotchas

•while (!feof(fp)) is the single most common C file I/O bug
•feof does not predict the next read -- it reports the last read's result
•fgetc returns int (not char) so it can represent EOF (-1) distinctly from all char values
•On error, feof may not be set -- always check ferror too

while (!feof(fp)) is wrong -- it processes the last item twice because feof only becomes true after a failed read. Instead, check the read function's return: while (fgets(buf, n, fp)) or while (fread(...) == 1).

•Use read function return as loop condition, not feof
•feof is for post-loop EOF vs error distinction

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("test.txt", "w");
    fprintf(fp, "10 20 30");
    fclose(fp);

    /* CORRECT: check return value */
    fp = fopen("test.txt", "r");
    int val;
    while (fscanf(fp, "%d", &val) == 1)
        printf("%d ", val); /* 10 20 30 */
    printf("\n");
    if (feof(fp)) printf("EOF\n"); /* distinguish from error */
    fclose(fp);
    remove("test.txt");
    return 0;
}

10 20 30 
EOF

while (!feof(fp)) duplicates the last item -- never use as loop condition

Question 8 / 12

What is the difference between binary mode and text mode in C file I/O?

When opening a file with fopen, the mode can be text (default) or binary (add b).

Text mode (default):

Performs newline translation:
- On Windows: \n is written as \r\n (CR+LF), and \r\n is read as \n
- On Unix/Linux: no translation (CR is not used)
May treat Ctrl+Z (0x1A) as EOF on Windows
fseek/ftell behavior is limited: only fseek(fp, 0, SEEK_SET) and fseek(fp, ftell_val, SEEK_SET) are portable

Binary mode ("rb", "wb", etc.):

No translation: bytes are read/written exactly as-is
No special EOF character
fseek/ftell work with exact byte offsets
Required for non-text data: images, executables, network protocols

On Unix/Linux: Text and binary modes are identical (no \r\n translation). The b flag is accepted but has no effect.

On Windows: The difference is critical. Reading a binary file in text mode corrupts data, and writing text in binary mode produces files without proper \r\n line endings.

Pseudo Code

Text mode (Windows):
  Write "Hello\n"  -> file contains "Hello\r\n" (6 bytes)
  Read "Hello\r\n" -> program sees "Hello\n" (5 chars)
  Ctrl+Z (0x1A)   -> treated as EOF

Binary mode:
  Write "Hello\n"  -> file contains "Hello\n" (6 bytes)
  Read "Hello\r\n" -> program sees "Hello\r\n" (7 bytes)
  0x1A             -> just another byte, not EOF

Unix: both modes are identical

Code

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

int main(void) {
    const char *text = "Line 1\nLine 2\nLine 3\n";

    /* Write in text mode */
    FILE *fp = fopen("text_mode.txt", "w"); /* text mode */
    if (!fp) return 1;
    fputs(text, fp);
    fclose(fp);

    /* Write same data in binary mode */
    fp = fopen("binary_mode.txt", "wb"); /* binary mode */
    if (!fp) return 1;
    fputs(text, fp);
    fclose(fp);

    /* Compare file sizes (differ on Windows, same on Unix) */
    fp = fopen("text_mode.txt", "rb");
    fseek(fp, 0, SEEK_END);
    long text_size = ftell(fp);
    fclose(fp);

    fp = fopen("binary_mode.txt", "rb");
    fseek(fp, 0, SEEK_END);
    long bin_size = ftell(fp);
    fclose(fp);

    printf("Text mode file size:   %ld bytes\n", text_size);
    printf("Binary mode file size: %ld bytes\n", bin_size);
    /* On Windows: text_size > bin_size (\r\n vs \n) */
    /* On Unix: sizes are equal */

    /* Binary I/O for non-text data */
    unsigned char data[] = {0x00, 0x1A, 0xFF, 0x0D, 0x0A};
    fp = fopen("raw.bin", "wb");
    fwrite(data, 1, sizeof(data), fp);
    fclose(fp);

    /* Read back in binary mode -- all bytes preserved */
    unsigned char buf[5];
    fp = fopen("raw.bin", "rb");
    fread(buf, 1, 5, fp);
    fclose(fp);
    printf("Binary read: ");
    for (int i = 0; i < 5; i++) printf("0x%02X ", buf[i]);
    printf("\n"); /* 0x00 0x1A 0xFF 0x0D 0x0A */

    remove("text_mode.txt");
    remove("binary_mode.txt");
    remove("raw.bin");
    return 0;
}

Text mode file size:   21 bytes
Binary mode file size: 21 bytes
Binary read: 0x00 0x1A 0xFF 0x0D 0x0A

Key Points

•Text mode translates \n to \r\n on Windows (no effect on Unix)
•Binary mode transfers bytes exactly -- no translation
•On Unix, text and binary modes are identical
•Always use binary mode for non-text data (images, structs, protocols)
•Text mode may treat 0x1A (Ctrl+Z) as EOF on Windows

Gotchas

•Reading a binary file in text mode on Windows corrupts data (0x1A stops reading, \r\n mangled)
•ftell in text mode may not return exact byte count on Windows
•Cross-platform code should always use "rb"/"wb" for binary data
•Git's autocrlf setting can cause similar \r\n confusion in source files

Text mode: translates \n to \r\n on Windows; binary mode: no translation. On Unix, both are identical. Always use "rb"/"wb" for non-text data to prevent corruption on Windows.

•Binary mode: no translation; text mode: newline translation on Windows
•Always use binary mode for non-text data

#include <stdio.h>

int main(void) {
    /* Text mode: \n may become \r\n on Windows */
    FILE *t = fopen("text.txt", "w");
    fprintf(t, "Hello\n");
    fclose(t);

    /* Binary mode: bytes written exactly as-is */
    FILE *b = fopen("data.bin", "wb");
    unsigned char raw[] = {0x00, 0x1A, 0xFF};
    fwrite(raw, 1, 3, b);
    fclose(b);

    remove("text.txt");
    remove("data.bin");
    return 0;
}

Ctrl+Z (0x1A) is treated as EOF in text mode on Windows

Question 9 / 12

How does tmpfile() work for creating temporary files?

tmpfile(void) creates a temporary binary file that is automatically deleted when it is closed or the program terminates.

Returns: A FILE * opened in "w+b" mode (binary read+write), or NULL on failure.

Properties:

File is automatically deleted on fclose or program exit
Opened in binary read+write mode
The file has no visible name in the filesystem (on most systems)
Thread-safe (each call creates a unique file)

Security advantages over tmpnam()/mktemp():

No TOCTOU (time-of-check-time-of-use) race condition
File is opened atomically -- no window for an attacker to replace it
tmpnam() is deprecated due to security vulnerabilities

For named temporary files: Use mkstemp() (POSIX) which creates and opens a file with a unique name atomically.

Limitations:

Cannot get the file path (unnamed file)
Binary mode only (no text mode option)
Maximum number of simultaneous tmp files is implementation-defined (TMP_MAX)

Pseudo Code

tmpfile():
  1. Creates a unique temporary file
  2. Opens it in "w+b" mode
  3. Returns FILE* (or NULL)
  4. Auto-deleted on fclose or exit

Usage:
  FILE *tmp = tmpfile();
  fwrite(data, ...);
  rewind(tmp);
  fread(data, ...);
  fclose(tmp);  /* file is automatically deleted */

Code

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

int main(void) {
    /* Create a temporary file */
    FILE *tmp = tmpfile();
    if (!tmp) {
        perror("tmpfile");
        return 1;
    }

    /* Write data to temporary file */
    const char *data = "Temporary data for processing";
    fwrite(data, 1, strlen(data), tmp);
    printf("Wrote %zu bytes to temp file\n", strlen(data));

    /* Seek back to beginning and read */
    rewind(tmp);
    char buf[100] = {0};
    size_t nread = fread(buf, 1, sizeof(buf) - 1, tmp);
    printf("Read back: [%s] (%zu bytes)\n", buf, nread);

    /* Use as scratch space for sorting or processing */
    int numbers[] = {50, 10, 40, 20, 30};
    rewind(tmp);
    fwrite(numbers, sizeof(int), 5, tmp);

    rewind(tmp);
    int sorted[5];
    fread(sorted, sizeof(int), 5, tmp);
    printf("Numbers: %d %d %d %d %d\n",
           sorted[0], sorted[1], sorted[2], sorted[3], sorted[4]);

    /* File is automatically deleted when closed */
    fclose(tmp);
    printf("Temp file automatically cleaned up\n");

    /* AVOID: tmpnam is insecure (TOCTOU race) */
    /* char *name = tmpnam(NULL); -- DEPRECATED */

    return 0;
}

Wrote 29 bytes to temp file
Read back: [Temporary data for processing] (29 bytes)
Numbers: 50 10 40 20 30
Temp file automatically cleaned up

Key Points

•tmpfile() creates an auto-deleting temporary file opened in w+b mode
•Returns FILE* or NULL; no visible filename in the filesystem
•Auto-deleted on fclose or program exit -- no cleanup needed
•Secure: no TOCTOU race condition (unlike tmpnam/mktemp)
•Use mkstemp() (POSIX) if you need a named temporary file

Gotchas

•tmpfile opens in binary mode only -- cannot use text mode
•Cannot get the path of the temporary file (it may be unnamed)
•On some systems, tmpfile may fail if /tmp is full or has wrong permissions
•tmpnam() is deprecated and insecure -- never use it in production

tmpfile() creates an anonymous temporary file in "w+b" mode that auto-deletes on close. Returns FILE * or NULL. Secure (no race condition). Use mkstemp() for named temp files.

•Auto-deleting temp file in w+b mode
•Secure alternative to deprecated tmpnam()

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

int main(void) {
    FILE *tmp = tmpfile();
    if (!tmp) { perror("tmpfile"); return 1; }

    const char *msg = "scratch data";
    fwrite(msg, 1, strlen(msg), tmp);
    rewind(tmp);

    char buf[64] = {0};
    fread(buf, 1, sizeof(buf) - 1, tmp);
    printf("%s\n", buf); /* scratch data */

    fclose(tmp); /* auto-deleted */
    return 0;
}

scratch data

Binary mode only; cannot retrieve the file path

Question 10 / 12

How do you handle file errors using ferror(), perror(), and errno?

C provides multiple mechanisms for detecting and reporting file I/O errors:

ferror(FILE *fp) Returns nonzero if the error indicator is set on the stream. Use after a read/write to check if an error occurred. Reset with clearerr(fp).

errno (from <errno.h>) A global variable set by system calls and library functions on failure. Common values:

ENOENT -- file not found
EACCES -- permission denied
ENOMEM -- out of memory
ENOSPC -- no space on device
EMFILE -- too many open files

perror(const char *prefix) Prints prefix: error_message\n to stderr, where error_message corresponds to current errno. Example: perror("fopen") might print fopen: No such file or directory.

strerror(int errnum) (from <string.h>) Returns a string describing the error number. Useful for custom error messages.

Error checking pattern:

FILE *fp = fopen(path, "r");
if (!fp) { perror(path); return -1; }
/* ... read ... */
if (ferror(fp)) { fprintf(stderr, "Read error\n"); }

Pseudo Code

Error handling workflow:
  1. Attempt operation (fopen, fread, fwrite)
  2. Check return value for failure indication
  3. On failure: check errno for specific error code
  4. Report: perror("context") or strerror(errno)
  5. For streams: ferror(fp) checks stream error flag
  6. clearerr(fp) resets both error and EOF flags

errno pitfall:
  errno is only valid immediately after a failed call
  Successful calls may or may not reset errno

Code

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

int main(void) {
    /* Attempt to open nonexistent file */
    FILE *fp = fopen("nonexistent.txt", "r");
    if (!fp) {
        /* Method 1: perror -- prints to stderr */
        perror("fopen nonexistent.txt");
        /* Output: fopen nonexistent.txt: No such file or directory */

        /* Method 2: strerror -- for custom messages */
        fprintf(stderr, "Error %d: %s\n", errno, strerror(errno));

        /* Method 3: check specific errno values */
        if (errno == ENOENT) {
            printf("File does not exist\n");
        } else if (errno == EACCES) {
            printf("Permission denied\n");
        }
    }

    /* Write to read-only location (if possible) */
    fp = fopen("/dev/null", "r"); /* read-only */
    if (fp) {
        int result = fputc('x', fp); /* write to read-only stream */
        if (result == EOF) {
            printf("fputc failed\n");
        }
        if (ferror(fp)) {
            printf("Stream error flag is set\n");
            clearerr(fp); /* reset error and EOF flags */
            printf("After clearerr: ferror=%d\n", ferror(fp)); /* 0 */
        }
        fclose(fp);
    }

    /* Proper error handling pattern */
    const char *path = "output.txt";
    fp = fopen(path, "w");
    if (!fp) {
        perror(path);
        return 1;
    }
    if (fprintf(fp, "data\n") < 0) {
        perror("fprintf");
        fclose(fp);
        return 1;
    }
    if (fclose(fp) != 0) {
        perror("fclose"); /* disk full detected at flush */
        return 1;
    }

    remove("output.txt");
    printf("All error handling demonstrated\n");
    return 0;
}

Key Points

•ferror(fp) checks the stream's error indicator flag
•errno holds the error code from the last failed call
•perror(prefix) prints 'prefix: error message' to stderr
•strerror(errno) returns the error message string for custom formatting
•clearerr(fp) resets both error and EOF indicators

Gotchas

•errno is only meaningful immediately after a failed call -- successful calls may change it
•ferror does not clear itself -- must call clearerr to reset
•perror is not thread-safe on some older systems (errno is thread-local since C11)
•Check fclose return on write streams -- disk-full errors may only appear at flush time

ferror(fp) checks stream errors. errno holds error codes. perror("msg") prints error to stderr. strerror(errno) returns error string. Always check return values first, then use these for diagnosis.

•perror for quick error reporting; strerror for custom messages
•errno valid only immediately after failure

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

int main(void) {
    FILE *fp = fopen("nonexistent.txt", "r");
    if (!fp) {
        perror("fopen"); /* fopen: No such file or directory */
        printf("errno=%d: %s\n", errno, strerror(errno));
        return 1;
    }
    fclose(fp);
    return 0;
}

fopen: No such file or directory
errno=2: No such file or directory

errno may be changed by successful calls -- save it immediately if needed

Question 11 / 12

What are the different file buffering modes and how does setvbuf() work?

The C standard I/O library buffers data to reduce the number of system calls. setvbuf() controls how a stream is buffered.

Three buffering modes:

_IOFBF (Fully buffered):
- Data is written/read in large chunks (BUFSIZ bytes, typically 4096-8192)
- Flush occurs when buffer is full, on fclose, or on explicit fflush
- Default for regular files
_IOLBF (Line buffered):
- Flush occurs on every newline \n, when buffer is full, or on fflush
- Default for stdout when connected to a terminal
- Useful for log files where you want each line immediately visible
_IONBF (Unbuffered):
- Every write/read goes directly to the OS (no buffering)
- Default for stderr
- Maximum I/O overhead but minimum latency

setvbuf(FILE *fp, char *buf, int mode, size_t size)

buf: user-provided buffer (or NULL for auto-allocated)
Must be called before any I/O operation on the stream
Returns 0 on success, nonzero on failure

setbuf(fp, buf) is an older, simpler version: setbuf(fp, buf) = setvbuf(fp, buf, buf ? _IOFBF : _IONBF, BUFSIZ).

Pseudo Code

_IOFBF (full): flush when buffer full or fclose/fflush
  Default for: regular files
  Best for: bulk I/O performance

_IOLBF (line): flush on \n, buffer full, or fflush
  Default for: stdout on terminal
  Best for: interactive output, log files

_IONBF (none): every I/O goes to OS immediately
  Default for: stderr
  Best for: debugging, error messages

setvbuf(fp, buf, mode, size):
  Must call before first I/O on fp
  buf=NULL lets library allocate
  Returns 0 on success

Code

#include <stdio.h>

int main(void) {
    FILE *fp;

    /* Fully buffered with custom buffer size */
    fp = fopen("full_buf.txt", "w");
    if (fp) {
        char buf[1024];
        setvbuf(fp, buf, _IOFBF, sizeof(buf));
        fprintf(fp, "Fully buffered - flushed on close or full buffer\n");
        /* Data may not be on disk yet */
        fflush(fp); /* force flush */
        fclose(fp); /* also flushes */
    }

    /* Line buffered */
    fp = fopen("line_buf.txt", "w");
    if (fp) {
        setvbuf(fp, NULL, _IOLBF, 0); /* NULL buf = auto-allocate */
        fprintf(fp, "Line 1 - flushed at newline\n"); /* flushed now */
        fprintf(fp, "Line 2 - also flushed\n");        /* flushed now */
        fclose(fp);
    }

    /* Unbuffered */
    fp = fopen("unbuf.txt", "w");
    if (fp) {
        setvbuf(fp, NULL, _IONBF, 0);
        fprintf(fp, "Every character goes to OS immediately\n");
        /* Each write is a system call -- slow but immediate */
        fclose(fp);
    }

    /* stderr is unbuffered by default */
    fprintf(stderr, "This appears immediately\n");

    /* stdout may be line-buffered (terminal) or fully buffered (pipe) */
    /* Force stdout to be unbuffered: */
    /* setvbuf(stdout, NULL, _IONBF, 0); */

    /* Demonstrate: stdout buffering affects output order */
    printf("stdout (may be buffered)");
    fprintf(stderr, "stderr (always immediate)\n");
    printf("\n"); /* \n may flush stdout if line-buffered */

    remove("full_buf.txt");
    remove("line_buf.txt");
    remove("unbuf.txt");
    return 0;
}

(stderr) This appears immediately
stdout (may be buffered)
(stderr) stderr (always immediate)
(Note: stderr output is unbuffered and appears immediately;
stdout may be reordered depending on buffering mode)

Key Points

•_IOFBF: fully buffered (default for files), best throughput
•_IOLBF: line buffered (default for terminal stdout), flush on newline
•_IONBF: unbuffered (default for stderr), every write is immediate
•setvbuf must be called before any I/O on the stream
•Pass NULL for buf to let the library allocate the buffer

Gotchas

•Calling setvbuf after performing I/O is undefined behavior
•stdout is fully buffered when redirected to a file (not line-buffered) -- can cause missing output on crash
•User-provided buffer must remain valid for the lifetime of the stream
•Unbuffered I/O (_IONBF) is very slow for bulk writes -- one system call per write

Three modes: _IOFBF (full, default for files), _IOLBF (line, default for terminal stdout), _IONBF (none, default for stderr). Set with setvbuf(fp, buf, mode, size) before any I/O.

•Files: fully buffered; terminal stdout: line buffered; stderr: unbuffered
•setvbuf must be called before first I/O on the stream

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("log.txt", "w");
    if (fp) {
        setvbuf(fp, NULL, _IOLBF, 0); /* line buffered */
        fprintf(fp, "Each line flushed immediately\n");
        fclose(fp);
    }
    /* stderr is unbuffered by default */
    fprintf(stderr, "Immediate output\n");
    remove("log.txt");
    return 0;
}

(stderr) Immediate output

stdout becomes fully buffered when redirected to a file -- crash loses unflushed data

Question 12 / 12

How do you read and parse a structured data file (like CSV) in C?

Reading structured data files (CSV, TSV, config files) in C requires combining line reading with string parsing.

General approach:

Read lines with fgets() (safe, bounded)
Parse each line with strtok(), sscanf(), or manual parsing
Store parsed data in structs or arrays

Parsing tools:

strtok(char *str, const char *delim): Splits a string by delimiters. First call: pass the string. Subsequent calls: pass NULL. Modifies the original string (replaces delimiters with \0).
sscanf(const char *str, const char *format, ...): Like fscanf but reads from a string. Good for fixed-format data.
Manual parsing with strchr()/strstr(): Most control, no destructive modification.

strtok pitfalls:

Modifies the original string
Not thread-safe (uses static internal state) -- use strtok_r() for thread safety
Cannot handle empty fields between consecutive delimiters (treats multiple delimiters as one)

For production CSV parsing: Consider a library (libcsv, etc.) that handles quoting, escaping, and edge cases properly.

Pseudo Code

CSV parsing algorithm:
  1. Open file: fp = fopen("data.csv", "r")
  2. Skip header: fgets(buf, ...)
  3. For each line:
     a. fgets(buf, sizeof(buf), fp)
     b. Parse fields: strtok(buf, ",") for first field
     c. strtok(NULL, ",") for subsequent fields
     d. Convert types: atoi(), atof(), strcpy()
     e. Store in struct array
  4. fclose(fp)

strtok sequence:
  strtok("Alice,20,3.8", ",")  -> "Alice"
  strtok(NULL, ",")             -> "20"
  strtok(NULL, ",")             -> "3.8"
  strtok(NULL, ",")             -> NULL (done)

Code

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

typedef struct {
    char name[50];
    int age;
    double gpa;
} Student;

/* Method 1: Parse CSV with strtok */
int parse_csv_strtok(const char *filename, Student *out, int max) {
    FILE *fp = fopen(filename, "r");
    if (!fp) { perror(filename); return -1; }

    char line[256];
    fgets(line, sizeof(line), fp); /* skip header */

    int count = 0;
    while (count < max && fgets(line, sizeof(line), fp)) {
        line[strcspn(line, "\n")] = '\0'; /* strip newline */

        char *name = strtok(line, ",");
        char *age_str = strtok(NULL, ",");
        char *gpa_str = strtok(NULL, ",");

        if (name && age_str && gpa_str) {
            strncpy(out[count].name, name, sizeof(out[count].name) - 1);
            out[count].name[sizeof(out[count].name) - 1] = '\0';
            out[count].age = atoi(age_str);
            out[count].gpa = atof(gpa_str);
            count++;
        }
    }
    fclose(fp);
    return count;
}

/* Method 2: Parse with sscanf (fixed format) */
int parse_csv_sscanf(const char *filename, Student *out, int max) {
    FILE *fp = fopen(filename, "r");
    if (!fp) return -1;

    char line[256];
    fgets(line, sizeof(line), fp); /* skip header */

    int count = 0;
    while (count < max && fgets(line, sizeof(line), fp)) {
        if (sscanf(line, "%49[^,],%d,%lf",
                   out[count].name, &out[count].age,
                   &out[count].gpa) == 3) {
            count++;
        }
    }
    fclose(fp);
    return count;
}

int main(void) {
    /* Create test CSV */
    FILE *fp = fopen("students.csv", "w");
    fprintf(fp, "name,age,gpa\n");
    fprintf(fp, "Alice,20,3.80\n");
    fprintf(fp, "Bob,22,3.50\n");
    fprintf(fp, "Charlie,21,3.95\n");
    fclose(fp);

    /* Parse with strtok */
    Student students[10];
    int n = parse_csv_strtok("students.csv", students, 10);
    printf("Parsed %d students (strtok):\n", n);
    for (int i = 0; i < n; i++) {
        printf("  %s, age %d, GPA %.2f\n",
               students[i].name, students[i].age, students[i].gpa);
    }

    /* Parse with sscanf */
    n = parse_csv_sscanf("students.csv", students, 10);
    printf("Parsed %d students (sscanf):\n", n);
    for (int i = 0; i < n; i++) {
        printf("  %s, age %d, GPA %.2f\n",
               students[i].name, students[i].age, students[i].gpa);
    }

    remove("students.csv");
    return 0;
}

Parsed 3 students (strtok):
  Alice, age 20, GPA 3.80
  Bob, age 22, GPA 3.50
  Charlie, age 21, GPA 3.95
Parsed 3 students (sscanf):
  Alice, age 20, GPA 3.80
  Bob, age 22, GPA 3.50
  Charlie, age 21, GPA 3.95

Key Points

•Read lines with fgets, parse with strtok or sscanf
•strtok modifies the original string and returns tokens one at a time
•sscanf with %[^,] pattern reads until a comma -- useful for CSV fields
•Always strip the trailing newline from fgets output before parsing
•Check that all expected fields were parsed before using the data

Gotchas

•strtok is not thread-safe -- use strtok_r for multithreaded code
•strtok treats consecutive delimiters as one -- empty CSV fields are skipped
•Real CSV has quoting rules (fields with commas, newlines) -- strtok cannot handle this
•atoi/atof have no error detection -- use strtol/strtod for robust parsing

Read lines with fgets(), parse with strtok(line, ",") or sscanf(line, "%[^,],%d,%lf", ...). Strip newline first. strtok is destructive and not thread-safe; use strtok_r in threaded code.

•fgets + strtok for basic CSV; sscanf for fixed formats
•strtok modifies the string and is not thread-safe

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

int main(void) {
    FILE *fp = fopen("data.csv", "w");
    fprintf(fp, "name,score\nAlice,95\nBob,87\n");
    fclose(fp);

    fp = fopen("data.csv", "r");
    char line[128];
    fgets(line, sizeof(line), fp); /* skip header */
    while (fgets(line, sizeof(line), fp)) {
        line[strcspn(line, "\n")] = '\0';
        char *name = strtok(line, ",");
        char *score = strtok(NULL, ",");
        if (name && score)
            printf("%s: %d\n", name, atoi(score));
    }
    fclose(fp);
    remove("data.csv");
    return 0;
}

Alice: 95
Bob: 87

strtok skips empty fields; real CSV needs a proper parser for quoting

Built by onllm.dev

Home GitHub Support awesomePrep