Chapter 10: File Input/Output In C Programming

Welcome to another chapter in our exciting journey through the C programming landscape. Today, we will be delving into the fascinating realm of File Input/Output. Buckle up, as we set off on this thrilling voyage of learning and exploration.

Basic File Operations

When we talk about programs, we’re often not dealing only with data that is inputted through a keyboard or displayed on a screen. Quite frequently, we need our programs to read from files or write to files. This is where file handling, or more specifically, File Input/Output operations, come into play.

To perform File I/O operations in C, we mainly use three basic functions: fopen(), fclose(), and fprintf() / fscanf(). The fopen() function is used to open a file, fclose() is used to close an open file, and fprintf() / fscanf() are used to write/read data to/from the file.

fopen() Function

The fopen() function is used to open a file and associate the file with a stream. The function returns a FILE pointer which can then be used with other file handling functions. The syntax for the fopen() function is as follows:

FILE *fopen(const char *filename, const char *mode);

In the above syntax, filename is a string literal that holds the name of the file to be opened, and mode is a string literal that defines the mode in which you wish to open the file. The mode can be “r” for reading, “w” for writing, “a” for appending, and these modes can be combined with “b” for binary files, or “+” to allow both reading and writing.

If the fopen() function is able to open the file, it returns a pointer to the file. If it cannot open the file, for instance, if the file does not exist and the mode is “r” (read), or if the file could not be created and the mode is “w” (write), it returns NULL.

fclose() Function

The fclose() function is used to close a file that has been opened for reading or writing. The syntax for the fclose() function is:

int fclose(FILE *stream);

In the above syntax, stream is the pointer to the FILE object that specifies the stream to be closed.

The fclose() function returns zero if the file is successfully closed. If an error occurs, it returns EOF (End Of File).

These two functions, fopen() and fclose(), are fundamental to working with files in C. It’s important to always close any files that you open within your program to prevent any data loss or corruption, and to free up system resources.

fprintf() Function

Starting with the first of our formidable pair, fprintf() is a function used to write formatted output to a file. It’s quite similar to the printf() function we frequently use for outputting to the console, but instead, it directs the output to a file.

Here’s the syntax of the fprintf() function:

int fprintf(FILE *stream, const char *format, …);

In this syntax, stream is the file pointer associated with the file we want to write to, format is a string that contains the text to be written to the file. It can optionally contain embedded format tags that are replaced by the values specified in subsequent arguments.

fscanf() Function

Moving on to the other half of our dynamic duo, the fscanf() function is used to read formatted input from a file. Similar to how scanf() is used to read input from the console, fscanf() reads from a file instead.

The syntax of fscanf() is as follows:

int fscanf(FILE *stream, const char *format, …);

In this syntax, stream is the file pointer associated with the file we want to read from, and format is the string that contains the type of data we expect to read.

fprintf() and fscanf() Example

To demonstrate these two in action, let’s assume we are working with a program that logs flight details. Here’s how we might use fprintf() and fscanf():

#include <stdio.h>

int main() {
    FILE *fptr;
    char flightNumber[10];
    char destination[50];
    float distance;

    // Open the flightlog.txt file in write mode
    fptr = fopen("flightlog.txt", "w");
    if(fptr == NULL) {
        printf("Error opening file!\n");
        return -1;
    }

    // Write some flight details to the file
    fprintf(fptr, "%s %s %f\n", "AC101", "Mars", 225.5);

    // Close the file
    fclose(fptr);

    // Reopen the file in read mode
    fptr = fopen("flightlog.txt", "r");
    if(fptr == NULL) {
        printf("Error opening file!\n");
        return -1;
    }

    // Read the flight details from the file
    fscanf(fptr, "%s %s %f", flightNumber, destination, &distance);
    printf("Flight Number: %s, Destination: %s, Distance: %.2f million km\n", flightNumber, destination, distance);

    // Close the file
    fclose(fptr);

    return 0;
}

In this code, we first open a file in write mode, write some flight details to it using fprintf(), then close it. We then reopen the same file in read mode, read the details back using fscanf(), and display them.

Understanding and using fprintf() and fscanf() for file I/O operations is a crucial skill in your C programming journey. They allow your programs to interact with files, thereby enabling data persistence and more complex data manipulation.

Reading and Writing Data to Files: A Detailed Example

To help illustrate the process of file operations in C, let’s consider a program designed to log flight details in an aerospace system.

#include <stdio.h>

// Define the Flight structure
struct Flight {
    char flightNumber[10];
    char destination[50];
    float distance;
};

int main() {
    // Create an instance of Flight
    struct Flight f1 = {"AC101", "Mars", 225.5};

    // Open the flightlog.txt file in write mode
    FILE *fptr = fopen("flightlog.txt", "w");

    if(fptr == NULL) {
        printf("Error opening file!\n");
        return -1;
    }

    // Write the flight details to the file
    fprintf(fptr, "Flight Number: %s\n", f1.flightNumber);
    fprintf(fptr, "Destination: %s\n", f1.destination);
    fprintf(fptr, "Distance: %.2f million km\n", f1.distance);

    // Close the file
    fclose(fptr);

    printf("Flight details logged successfully!\n");

    return 0;
}

In this code, we first define a Flight structure that holds information about a flight. We then create a Flight instance f1 and fill it with some data. The fopen() function is then used to open a file called flightlog.txt in write mode (“w”). If the file doesn’t exist, it is created.

We then check if the file was opened successfully. If fopen() fails to open the file, it returns NULL. If the file is opened successfully, we use fprintf() to write the flight details to the file. Once we’re done with the file, we use fclose() to close it.

Conclusion

Mastering File Input/Output operations is crucial in your journey as a C programmer. It allows your programs to persist data, log events, and interact with data in a more sophisticated manner. The impact of file handling is seen across domains, from simple text processing applications to complex aerospace systems.

I hope you enjoyed today’s journey through File Input/Output in C. Remember, the beauty of programming lies in continuous learning and exploration. So, keep learning, keep coding, and I’ll see you in our next exploration. Safe travels through the coding cosmos!