How to use simple file input and output in C

Mastering File Input and Output in C

Learn the fundamentals of reading from and writing to files in C, covering basic operations, error handling, and best practices for robust file management.

File input and output (I/O) are fundamental operations in C programming, allowing your programs to interact with the persistent storage of a computer. Whether you need to save user data, log events, or process large datasets, understanding how to read from and write to files is crucial. This article will guide you through the essential functions and concepts for performing simple file I/O in C, ensuring your programs can effectively manage external data.

Opening and Closing Files: The Foundation of File I/O

Before you can perform any read or write operations, you must first open a file. The fopen() function is used for this purpose, returning a pointer to a FILE structure, which acts as a handle to the opened file. It takes two arguments: the file path and the mode in which to open the file. After you're done with a file, it's critical to close it using fclose() to release system resources and ensure all buffered data is written to disk.

#include <stdio.h>

int main() {
    FILE *fp;

    // Open a file in write mode ("w")
    fp = fopen("example.txt", "w");

    // Check if the file was opened successfully
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    printf("File 'example.txt' opened successfully for writing.\n");

    // Close the file
    fclose(fp);
    printf("File closed.\n");

    return 0;
}

Opening and closing a file in C

flowchart TD
    A[Start Program] --> B{Call fopen("filename", "mode")}
    B --> C{Is fp NULL?}
    C -->|Yes| D[Handle Error: perror, exit]
    C -->|No| E[File Opened Successfully]
    E --> F[Perform File Operations (Read/Write)]
    F --> G{Call fclose(fp)}
    G --> H[End Program]

Basic File I/O Workflow in C

Writing Data to Files

Once a file is successfully opened in a write-compatible mode ("w", "a", "r+", "w+", "a+"), you can write data to it. C provides several functions for writing, including fputc() for single characters, fputs() for strings, and fprintf() for formatted output, similar to printf().

#include <stdio.h>

int main() {
    FILE *fp;
    char text[] = "Hello, C File I/O!\n";
    int number = 123;

    fp = fopen("output.txt", "w"); // Open for writing, creates/truncates file
    if (fp == NULL) {
        perror("Error opening file for writing");
        return 1;
    }

    // Write a string
    fputs(text, fp);

    // Write formatted data
    fprintf(fp, "The answer is %d.\n", number);

    // Write a single character
    fputc('A', fp);
    fputc('\n', fp);

    printf("Data written to 'output.txt'.\n");
    fclose(fp);
    return 0;
}

Writing various data types to a file

Reading Data from Files

Reading data from files is just as straightforward. Functions like fgetc() read a single character, fgets() reads a line (or a specified number of characters), and fscanf() reads formatted input. When reading, it's important to handle the end-of-file (EOF) condition to prevent reading past the file's content.

#include <stdio.h>

int main() {
    FILE *fp;
    char buffer[100];
    char ch;
    int value;

    fp = fopen("output.txt", "r"); // Open for reading
    if (fp == NULL) {
        perror("Error opening file for reading");
        return 1;
    }

    printf("\nReading character by character:\n");
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }

    // Rewind the file pointer to the beginning for next read operation
    rewind(fp);

    printf("\nReading line by line:\n");
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }

    // Rewind again for formatted read
    rewind(fp);

    printf("\nReading formatted data:\n");
    // Assuming the file contains "The answer is 123." on a line
    if (fscanf(fp, "The answer is %d.\n", &value) == 1) {
        printf("Found number: %d\n", value);
    }

    fclose(fp);
    return 0;
}

Reading various data types from a file

1. Step 1: Include Standard I/O Header

Start by including the <stdio.h> header file, which contains the declarations for file I/O functions.

2. Step 2: Declare a File Pointer

Declare a pointer of type FILE* (e.g., FILE *fp;) to hold the file handle returned by fopen().

3. Step 3: Open the File

Use fopen("filename", "mode") to open the file. Remember to check if the returned pointer is NULL to handle potential errors.

4. Step 4: Perform Read/Write Operations

Use functions like fputc(), fputs(), fprintf() for writing, or fgetc(), fgets(), fscanf() for reading, depending on your data type and format.

5. Step 5: Close the File

Always call fclose(fp) when you are finished with the file to ensure data integrity and release system resources.