Authors Note: I am learning as I write this series so please point out errors or better ways to do things if you see them in this article

Introduction: Why Save Your Data?

Have you ever spent hours entering data into a program, only to lose it all when you shut down your computer? If you’ve experienced this frustration, you’re not alone! None of the simple C programs beginners typically write can store data permanently.

Think about it: when you create a variable, assign it a value like 14, and then turn off your computer, that value disappears completely. When you restart your computer, that information is gone forever.

This is where file handling becomes essential. In this comprehensive guide, we’ll explore how to save data to your computer’s disk using sequential files in C. When data is saved to disk, it remains there until you explicitly change or delete it—just like music saved to your device stays there until you remove it.

What Are Disk Files?

Disk files are containers that hold data on your computer’s storage devices. You’re already familiar with files if you’ve ever saved a C program—that .c file is stored on your disk! Files can contain either program code or data.

There’s an important distinction to understand about files:

Sequential-access files: Data must be read or written in order, from beginning to end
Random-access files: Data can be accessed at any position without reading through all preceding data

💡 Helpful Analogy: Think of sequential files like an old VHS tape where you must fast-forward through the content in order. Random-access files are like DVDs or streaming services where you can jump directly to any scene.

In this tutorial, we’ll focus specifically on sequential files, which are perfect for beginners and cover many common use cases.

Step 1: Understanding File Pointers

Before you can work with files in C, you need to understand file pointers. Just as regular pointers hold memory addresses of variables, file pointers hold information about the disk location of files you’re working with.

To work with files in C, you’ll need to: 1. Include the standard I/O library 2. Define a file pointer variable 3. Connect that pointer to a physical file

Here’s how you define a file pointer:

#include <stdio.h>
FILE *fptr; /* Defines a file pointer named fptr */

⚠️ Important: Most C programmers define their file pointers globally (before main()) so the entire program can access them. The keyword FILE is defined in stdio.h, which is why you must include this header file when working with disk files.

Step 2: Opening Files with fopen()

Before reading from or writing to a file, you must open it using the fopen() function. This function connects your file pointer to a physical file and prepares the file for operations.

The basic syntax is:

file_pointer = fopen("filename", "mode");

Here’s a practical example:

#include <stdio.h>

FILE *fptr; // Defines a file pointer

int main() {
    fptr = fopen("data.txt", "w");
    
    // File operations would go here
    
    fclose(fptr); // Always close files when done!
    return 0;
}

File Opening Modes

When opening a file, you must specify how you intend to use it with one of these modes:

Mode	Description
“w”	Write mode: Creates a new file (overwrites if it exists)
“r”	Read mode: Opens an existing file for reading (error if file doesn’t exist)
“a”	Append mode: Adds data to the end of an existing file (creates file if it doesn’t exist)

⚠️ Warning: Opening a file in “w” mode will erase any existing data in that file! Use “a” mode if you want to preserve the existing content.

Error Checking

Always check if your file opened successfully:

fptr = fopen("data.txt", "w");
if (fptr == NULL) {
    printf("Error opening file!\n");
    return 1; // Exit with error code
}

Step 3: Writing to Sequential Files

To write data to a file, we use fprintf(), which works just like printf() but writes to a file instead of the screen.

Here’s a basic example of writing to a file:

#include <stdio.h>

int main() {
    FILE *fptr;
    
    fptr = fopen("students.txt", "w");
    
    if (fptr == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    
    // Writing formatted data to file
    fprintf(fptr, "Student ID: %d\n", 101);
    fprintf(fptr, "Name: %s\n", "John Smith");
    fprintf(fptr, "Score: %.2f\n", 85.5);
    
    fclose(fptr);
    printf("Data successfully written to file!\n");
    
    return 0;
}

Step 4: Reading from Sequential Files

To read data from a file, we can use functions like fgets() which reads a line at a time from a file into a character array.

Here’s how to read data from a file:

#include <stdio.h>

int main() {
    FILE *fptr;
    char buffer[100]; // Buffer to store each line
    
    fptr = fopen("students.txt", "r");
    
    if (fptr == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    
    printf("File contents:\n");
    
    // Read and display each line until end of file
    while (!feof(fptr)) {
        fgets(buffer, 100, fptr);
        if (!feof(fptr)) { // Check again to avoid printing last line twice
            printf("%s", buffer);
        }
    }
    
    fclose(fptr);
    return 0;
}

💡 Tip: The feof() function returns true when you’ve reached the end of the file. This helps you avoid reading beyond the file’s contents.

Step 5: Appending to Sequential Files

If you want to add data to an existing file without erasing its contents, use append mode (“a”):

#include <stdio.h>

int main() {
    FILE *fptr;
    
    fptr = fopen("students.txt", "a");
    
    if (fptr == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    
    // Adding more data to the existing file
    fprintf(fptr, "\n--- New Records ---\n");
    fprintf(fptr, "Student ID: %d\n", 102);
    fprintf(fptr, "Name: %s\n", "Emma Johnson");
    fprintf(fptr, "Score: %.2f\n", 92.5);
    
    fclose(fptr);
    printf("Data successfully appended to file!\n");
    
    return 0;
}

Your Turn! Building a Simple Student Record System

Let’s practice what we’ve learned by building a simple student record system that: 1. Creates a file to store student records 2. Allows adding new student records 3. Displays all saved records

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

// Structure to hold student data
struct Student {
    int id;
    char name[50];
    float score;
};

void createFile();
void addStudent();
void displayRecords();

int main() {
    int choice;
    
    do {
        printf("\nSTUDENT RECORD SYSTEM\n");
        printf("1. Create new records file\n");
        printf("2. Add student record\n");
        printf("3. Display all records\n");
        printf("4. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);
        
        switch(choice) {
            case 1:
                createFile();
                break;
            case 2:
                addStudent();
                break;
            case 3:
                displayRecords();
                break;
            case 4:
                printf("Exiting program. Goodbye!\n");
                break;
            default:
                printf("Invalid choice. Please try again.\n");
        }
    } while(choice != 4);
    
    return 0;
}

void createFile() {
    FILE *fptr;
    
    fptr = fopen("students.txt", "w");
    
    if (fptr == NULL) {
        printf("Error creating file!\n");
        return;
    }
    
    fprintf(fptr, "STUDENT RECORDS DATABASE\n");
    fprintf(fptr, "ID\tNAME\t\tSCORE\n");
    fprintf(fptr, "----------------------------\n");
    
    fclose(fptr);
    printf("New records file created successfully!\n");
}

void addStudent() {
    FILE *fptr;
    struct Student student;
    
    fptr = fopen("students.txt", "a");
    
    if (fptr == NULL) {
        printf("Error opening file. Create a new file first!\n");
        return;
    }
    
    // Clear input buffer
    while(getchar() != '\n');
    
    // Get student details
    printf("Enter student ID: ");
    scanf("%d", &student.id);
    
    printf("Enter student name: ");
    while(getchar() != '\n'); // Clear buffer again
    fgets(student.name, 50, stdin);
    
    // Remove newline character from name
    for(int i = 0; student.name[i] != '\0'; i++) {
        if(student.name[i] == '\n') {
            student.name[i] = '\0';
            break;
        }
    }
    
    printf("Enter student score: ");
    scanf("%f", &student.score);
    
    // Write to file
    fprintf(fptr, "%d\t%s\t\t%.2f\n", student.id, student.name, student.score);
    
    fclose(fptr);
    printf("Student record added successfully!\n");
}

void displayRecords() {
    FILE *fptr;
    char buffer[100];
    
    fptr = fopen("students.txt", "r");
    
    if (fptr == NULL) {
        printf("Error opening file. No records found!\n");
        return;
    }
    
    printf("\n--- DISPLAYING ALL RECORDS ---\n");
    
    while (!feof(fptr)) {
        if (fgets(buffer, 100, fptr) != NULL) {
            printf("%s", buffer);
        }
    }
    
    fclose(fptr);
}

See Solution

When you run this program:

Choose option 1 to create a new file
Choose option 2 to add student records
Choose option 3 to display all records
Choose option 4 to exit

The data will be saved in “students.txt” in your program’s directory.

Common Mistakes and How to Avoid Them

When working with files in C, beginners often encounter these issues:

Forgetting to close files: Always use fclose() when you’re done with a file
Not checking if a file opened successfully: Always verify with if (fptr == NULL)
Opening files in wrong mode: Using “w” overwrites existing files
Not checking for end-of-file: Use feof() to avoid reading beyond file content
Forgetting file pointer positions: In fprintf(), the file pointer is the first parameter, but in fgets(), it’s the last parameter

Key Takeaways

✅ Files allow programs to store data permanently on disk storage ✅ Sequential files must be accessed in order from beginning to end ✅ Always open files with fopen() before using them ✅ Use the appropriate mode when opening files: “w” (write), “r” (read), or “a” (append) ✅ Write to files using fprintf() which works like printf() but outputs to a file ✅ Read from files using fgets() to retrieve line by line content ✅ Always check for errors when opening files and for the end-of-file condition when reading ✅ Close all files with fclose() when you’re finished with them

FAQs

1. What’s the difference between sequential and random access files?

Sequential files must be read or written in order from start to finish, like a tape. Random access files allow you to jump to any position directly, like a DVD.

2. Can I open multiple files at the same time?

Yes! You just need to create a separate file pointer for each file you want to open simultaneously.

3. What happens if I try to open a file that doesn’t exist in “r” mode?

Opening a non-existent file in read mode will fail, and fopen() will return NULL.

4. How do I know when I’ve reached the end of a file?

Use the feof() function to check if you’ve reached the end of file during reading operations.

5. Can I read and write to a file at the same time?

Yes, by opening the file in “r+” mode (read and write). However, this requires careful management of the file position.

Conclusion: Start Saving Your Data Today!

Congratulations! You now understand how to create, read from, and write to sequential files in C. This fundamental skill opens up endless possibilities for your programs—from saving user preferences to storing large datasets.

The ability to save data to files is what transforms simple programs into truly useful applications that can maintain information between runs. Now your programs can remember things long after they’ve been closed!

Ready to take your C programming skills to the next level? Start incorporating file handling into your projects today and watch how they transform into more powerful, useful applications!

What will you build with your new file handling skills? Let us know in the comments below!

References

Happy Coding! 🚀

You can connect with me at any one of the below:

Telegram Channel here: https://t.me/steveondata

LinkedIn Network here: https://www.linkedin.com/in/spsanderson/

Mastadon Social here: https://mstdn.social/@stevensanderson

RStats Network here: https://rstats.me/@spsanderson

GitHub Network here: https://github.com/spsanderson

Bluesky Network here: https://bsky.app/profile/spsanderson.com

My Book: Extending Excel with Python and R here: https://packt.link/oTyZJ

You.com Referral Link: https://you.com/join/EHSLDTL6