How Do I Read and Write Files in C?

After this lesson, you will be able to:

• Open and close files using fopen/fclose with correct mode and NULL check
• Write to files with fprintf and read with fscanf, checking return values
• Read lines safely with fgets and strip the trailing newline
• Explain why while (!feof(fp)) is a bug

Beyond the Keyboard

Every program so far has read from the keyboard (stdin) and written to the screen (stdout). Real programs read configuration files, process data files, and write reports. C’s file I/O functions mirror printf/scanf — once you know those, files are straightforward.

File Operations

Opening and Closing Files

FILE *fp = fopen("students.txt", "r");    // Open for reading
if (fp == NULL)
{
    fprintf(stderr, "Error: cannot open students.txt\n");
    return 1;
}

// ... read from fp ...

fclose(fp);    // Always close when done

File modes:

Common Pitfall: Always check if fopen returns NULL. The file might not exist, you might not have permission, or the path might be wrong. Skipping this check leads to crashes when you try to read from a NULL pointer.

Writing to Files

fprintf works exactly like printf, but writes to a file:

FILE *fp = fopen("output.txt", "w");
if (fp == NULL) { /* handle error */ }

fprintf(fp, "Name: %s\n", name);
fprintf(fp, "GPA: %.2f\n", gpa);

fclose(fp);

Reading from Files

fscanf — formatted reading (like scanf):

FILE *fp = fopen("data.txt", "r");

int id;
double gpa;
while (fscanf(fp, "%d %lf", &id, &gpa) == 2)
{
    printf("ID: %d, GPA: %.2f\n", id, gpa);
}

fclose(fp);

fgets — read a line (safer):

char line[256];
while (fgets(line, sizeof(line), fp) != NULL)
{
    line[strcspn(line, "\n")] = '\0';    // Strip newline
    printf("Line: %s\n", line);
}

The Trick: fgets is generally safer than fscanf for reading text. It prevents buffer overflows and handles lines with spaces. Read the whole line with fgets, then parse it with sscanf or strtok.

The feof Trap

Common Pitfall: Never use while (!feof(fp)) as your loop condition. feof returns true only after a read has already failed — so the last iteration processes garbage data. Instead, check the return value of your read function:

// WRONG:
while (!feof(fp))
{
    fscanf(fp, "%d", &value);    // Processes garbage on last iteration
}

// RIGHT:
while (fscanf(fp, "%d", &value) == 1)
{
    // Process value
}

FILE *fp = fopen("data.txt", "r");
if (fp == NULL)
{
    perror("data.txt");    // Writes to stderr, not stdout
    return 1;
}

Reading Structs from Files

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

int read_students(const char *filename, Student roster[], int max)
{
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) return -1;

    int count = 0;
    char line[256];

    while (count < max && fgets(line, sizeof(line), fp) != NULL)
    {
        line[strcspn(line, "\n")] = '\0';
        sscanf(line, "%49s %d %lf",
               roster[count].name,
               &roster[count].id,
               &roster[count].gpa);
        count++;
    }

    fclose(fp);
    return count;
}

From Java: In Java, you’d use Scanner scanner = new Scanner(new File("data.txt")) with scanner.nextLine() and scanner.nextInt(). C’s fopen/fgets/fscanf serve the same purpose — but you manage the file handle yourself (no automatic closing, no try-with-resources). Always fclose when done.

Big Picture: File I/O transforms your programs from interactive toys into tools that process real data. Every database, compiler, and web server reads and writes files using the same primitives you just learned. Combined with structs, you can build programs that load, process, and save structured records — which is what most real software does.

Files Connect Programs to Data

File I/O is how your programs interact with the outside world — reading data sets, writing reports, processing logs. Combined with structs, you can read structured records from files, manipulate them in memory, and write results back.

Next: sorting structs. You’ll sort your struct arrays by different fields — name, ID, GPA — using the selection sort you learned in Lesson 2.14, adapted for structured data.