By the end of this lesson, cadets will be able to:

1. Open, read, write, and close files in a C program. (Outcome 2)
2. Distinguish between text-mode and binary-mode file operations. (Outcome 2)
3. Parse formatted input from files using fscanf and from strings using sscanf. (Outcome 2)
4. Handle file operation errors appropriately. (Outcomes 3, 7)

Complete before class. These give you the vocabulary and the library calls. The lecture will assume you have read them.

If a reading feels dry, skim once for landmarks, then read again for detail when you sit down for the lab. Reading docs is a course skill; we will keep practicing it.

Before class, work through these three things. Total time: about 30 minutes.

1. Read both assigned readings. Beej-C Chapter 9 first (concepts), then the <stdio.h> reference (the specifics). Stop and write down the answers to:
   • What does fopen return when the file does not exist?
   • What is the difference between fgetc returning a value and fgets returning a value?
   • Why is the return type of fgetc int and not char?
   • What does sscanf return on success, and what does it return when only some of the fields matched?
2. Skim the lab README. You do not need to start the lab. Just know what you are signing up for: parsing flight log records, handling malformed input, summary output. The lab will make a lot more sense after the lesson and the walkthrough.
3. Bring your laptop ready to compile and run C. The walkthrough lives in the browser, but the lab needs your terminal and your gcc.

Open Lesson 21 slides →

Mental model: a file is bytes with a cursor

A file on disk is just a sequence of bytes. C's standard library gives you a FILE pointer, which is an opaque handle that points to a kernel object tracking three things about your access to that file:

• Which file you have open
• What mode you opened it in (read, write, append, read-plus-write)
• A cursor: the position in the file where the next read or write will happen

Every operation either reads from the cursor and advances it, writes at the cursor and advances it, or moves the cursor without reading or writing (fseek). The walkthrough in Section 5 makes the cursor visible so you can watch it move.

fopen and fclose: getting a FILE pointer

FILE *f = fopen("flights.log", "r");
if (f == NULL) {
    fprintf(stderr, "cannot open flights.log\n");
    return 1;
}
/* ... read or write through f ... */
fclose(f);

Common modes:

fclose flushes any pending writes and releases the file handle. Always close what you open. Forgetting fclose leaks resources and can lose unflushed writes if the process ends abnormally.

Reading: fgetc, fgets, fscanf

Three reading patterns, from finest grained to most structured:

• fgetc(f) reads one byte and returns it as an int. On EOF, returns the special value EOF (which is -1). That is why the return type is int, not char: it needs to represent every possible byte plus EOF.
• fgets(buf, n, f) reads up to n - 1 characters into buf, stopping at a newline or EOF. The newline is included in the buffer if it was read. Returns NULL at EOF. This is your line-by-line workhorse.
• fscanf(f, fmt, ...) parses formatted fields directly from the file. Powerful but brittle: any deviation in the input throws off the parse and leaves the cursor at the failure point. Most C programmers prefer the two-step pattern of fgets + sscanf for that reason: read a whole line first, then parse it.

The canonical line-reading loop:

char line[256];
while (fgets(line, sizeof line, f) != NULL) {
    /* process one line */
}

sscanf: the parser you will use most

sscanf reads from a string instead of a file. Combined with fgets, it gives you robust line parsing. Format specifiers you need today:

sscanf returns the number of fields it matched. Always check the return value to detect malformed input. Worked example: parsing a flight record

char tail[8], depart[5], arrive[5];
int  duration, fuel;

int matched = sscanf(line, "%7[^,],%4[^,],%4[^,],%d,%d",
                     tail, depart, arrive, &duration, &fuel);

if (matched != 5) {
    /* malformed line; skip and warn */
}

Writing: fputc, fputs, fprintf

• fputc(c, f) writes one byte.
• fputs(str, f) writes a string. Note: unlike puts, fputs does not add a newline. You include the \n yourself if you want one.
• fprintf(f, fmt, ...) is printf but to a file. Same format specifiers as you already know.

An especially useful pattern: fprintf(stderr, ...) writes error messages to the standard error stream so they do not get mixed in with your program's normal output. The lab autograder checks stdout and stderr separately for exactly this reason.

Error handling: check every return value

Every file operation can fail. Things that go wrong in real programs:

• The file does not exist (read mode).
• You do not have permission to read or write it.
• The disk is full (write mode).
• The input file is malformed in unexpected ways.
• The cadet at the keyboard typed the wrong filename.

The standard library tells you what went wrong through return values. The discipline is to check, every time:

Text mode vs binary mode

Add a "b" to the mode string to open in binary mode: "rb", "wb", "r+b".

On Linux and macOS, text and binary modes are identical; the distinction is a no-op. On Windows, text mode silently converts "\r\n" sequences in the file to "\n" in your buffer (and vice versa on write). Binary mode passes bytes through unchanged.

Rule of thumb: read CSV, logs, source code, and other text content in text mode. Read images, executables, and serialized data structures in binary mode. When in doubt, binary is safer because it never lies to you about what is in the file.

Three things to do in class. Use the checklist to track your progress.

• Work through the File I/O walkthrough below. Fourteen guided tasks covering fopen, fgetc, fseek, fgets, fputs, ftell, and fclose. The right pane shows the cursor walking through the file. About 25 minutes.
• Get the Lab 21 starter from GitHub Classroom. Clone the repo, read the README, run make to confirm the starter compiles (it does; the TODO stubs are no-ops), and read flight.h carefully.
  Accept Lab 21 on GitHub Classroom →
• Begin Lab 21: Flight Log Reader. Implement parse_flight_line first; it is the function you can write entirely from what we covered today. Get the basic case passing, then tackle malformed input. Submit to Gradescope when you have at least the basic functional test passing.

File I/O Walkthrough

Fourteen tasks across four sections. Type each statement at the prompt. The terminal pane shows what your statement did; the right pane shows each open file as a row of bytes with the cursor marked underneath.

• Finish Lab 21 if you did not complete it in class. Submit to Gradescope before Lesson 22.
• Read Beej-C Chapter 16 (Command-Line Arguments) for Lesson 22.
• Replay the walkthrough in free mode. Open a file you create with fopen(..., "w"), write some bytes with fputc, then close and reopen for reading. The cursor behavior on freshly-written files is a common point of confusion.
• Heads up: Quiz 8 (File I/O) is at Lesson 22, covering today's material. Be sure your reading and walkthrough are solid before then.