WebsiteLogo

File Handling

Opening, reading from, writing to, and closing files in C. Using functions like `fopen`, `fclose`, `fread`, `fwrite`, `fprintf`, and `fscanf`.

⬅ Previous Next ➡

Working with Binary Files in C

Binary files store data in a format directly understandable by the computer, without any character encoding or translation. This is in contrast to text files, which store data as sequences of characters. Binary files are often more compact and can be read and written faster than text files, especially when dealing with complex data structures.

Why Use Binary Files?

  • Efficiency: Binary files typically require less storage space compared to text files for the same data.
  • Speed: Reading and writing binary data can be faster because no conversion to/from text format is necessary.
  • Data Preservation: Binary files preserve the exact bit-level representation of data, which is crucial for certain types of data (e.g., images, audio, custom data structures).

Opening and Closing Binary Files

In C, you use the fopen() function to open a file, and the fclose() function to close it. When working with binary files, you need to specify the "binary" mode by adding the 'b' flag to the mode string.

 #include <stdio.h>

int main() {
    FILE *fp;

    // Open a binary file for writing
    fp = fopen("data.bin", "wb");  // "wb" - write binary

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // ... perform write operations here ...

    // Close the file
    fclose(fp);

    // Open a binary file for reading
    fp = fopen("data.bin", "rb");  // "rb" - read binary

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // ... perform read operations here ...

    // Close the file
    fclose(fp);

    return 0;
}

Here's a breakdown of the modes:

  • "wb": Opens a binary file for writing. Creates the file if it doesn't exist, or overwrites it if it does.
  • "rb": Opens a binary file for reading.
  • "ab": Opens a binary file for appending. Writes are added to the end of the file.
  • "wb+": Opens a binary file for both reading and writing. Creates the file if it doesn't exist, or overwrites it if it does.
  • "rb+": Opens a binary file for both reading and writing. The file must already exist.
  • "ab+": Opens a binary file for both reading and appending. Creates the file if it doesn't exist.

Reading from Binary Files

The fread() function is used to read data from a binary file. It reads a specified number of bytes from the file into a buffer in memory.

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

int main() {
    FILE *fp;
    int data[5];
    int i;

    fp = fopen("data.bin", "rb");
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // Read 5 integers from the file into the 'data' array
    size_t elements_read = fread(data, sizeof(int), 5, fp);

    if (elements_read != 5) {
       fprintf(stderr, "Error reading all elements.  Read %zu elements.\n", elements_read);
       fclose(fp); // Close the file before exiting
       return 1;
    }

    fclose(fp);

    printf("Data read from file:\n");
    for (i = 0; i < 5; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");

    return 0;
}

Explanation:

  • fread(ptr, size, count, fp):
    • ptr: A pointer to the buffer where the read data will be stored.
    • size: The size of each element to be read (in bytes).
    • count: The number of elements to read.
    • fp: The file pointer.
  • fread() returns the number of elements successfully read. It's crucial to check this return value to ensure that the read operation was successful.
  • Error handling is included to check if the file was opened successfully and if the expected number of elements were read.

Writing to Binary Files

The fwrite() function is used to write data to a binary file. It writes a specified number of bytes from a buffer in memory to the file.

 #include <stdio.h>

int main() {
    FILE *fp;
    int data[5] = {10, 20, 30, 40, 50};
    int i;

    fp = fopen("data.bin", "wb");
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // Write 5 integers from the 'data' array to the file
    size_t elements_written = fwrite(data, sizeof(int), 5, fp);

    if (elements_written != 5) {
        fprintf(stderr, "Error writing all elements. Wrote %zu elements.\n", elements_written);
        fclose(fp); // Close the file before exiting
        return 1;
    }


    fclose(fp);

    printf("Data written to file.\n");

    return 0;
}

Explanation:

  • fwrite(ptr, size, count, fp):
    • ptr: A pointer to the buffer containing the data to be written.
    • size: The size of each element to be written (in bytes).
    • count: The number of elements to write.
    • fp: The file pointer.
  • fwrite() returns the number of elements successfully written. Check the return value for error handling.

Reading and Writing Structures

Binary files are particularly useful for storing complex data structures like structures directly. You can read and write an entire structure with a single fread() or fwrite() call.

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

// Define a structure
typedef struct {
    char name[50];
    int age;
    float salary;
} Employee;

int main() {
    FILE *fp;
    Employee emp1 = {"John Doe", 30, 50000.0};
    Employee emp2;

    // Write the structure to a binary file
    fp = fopen("employee.bin", "wb");
    if (fp == NULL) {
        perror("Error opening file for writing");
        return 1;
    }

    size_t elements_written = fwrite(&emp1, sizeof(Employee), 1, fp);

    if (elements_written != 1) {
        fprintf(stderr, "Error writing structure to file.\n");
        fclose(fp);
        return 1;
    }
    fclose(fp);

    printf("Employee data written to file.\n");

    // Read the structure from the binary file
    fp = fopen("employee.bin", "rb");
    if (fp == NULL) {
        perror("Error opening file for reading");
        return 1;
    }

    size_t elements_read = fread(&emp2, sizeof(Employee), 1, fp);

    if (elements_read != 1) {
        fprintf(stderr, "Error reading structure from file.\n");
        fclose(fp);
        return 1;
    }

    fclose(fp);

    printf("\nEmployee data read from file:\n");
    printf("Name: %s\n", emp2.name);
    printf("Age: %d\n", emp2.age);
    printf("Salary: %.2f\n", emp2.salary);

    return 0;
}

Explanation:

  • The sizeof(Employee) is used to specify the size of the structure when calling fwrite() and fread().
  • The address of the structure (&emp1 and &emp2) is passed as the first argument to fwrite() and fread().
  • It is *critical* to use the same structure definition for both writing and reading, otherwise you will get incorrect data or segmentation faults.
  • Error handling is included to check for successful file opening, reading and writing.

Reading and Writing Arrays of Structures

You can also easily read and write arrays of structures. This is a common pattern when dealing with large datasets.

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

// Define a structure
typedef struct {
    char name[50];
    int age;
} Person;

int main() {
    const int num_people = 3;
    Person people[num_people] = {
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 35}
    };
    FILE *fp;

    // Write the array of structures to a binary file
    fp = fopen("people.bin", "wb");
    if (fp == NULL) {
        perror("Error opening file for writing");
        return 1;
    }

    size_t elements_written = fwrite(people, sizeof(Person), num_people, fp);
    if (elements_written != num_people) {
        fprintf(stderr, "Error writing array to file.\n");
        fclose(fp);
        return 1;
    }

    fclose(fp);
    printf("People data written to file.\n");

    // Read the array of structures back from the file
    Person read_people[num_people];
    fp = fopen("people.bin", "rb");
    if (fp == NULL) {
        perror("Error opening file for reading");
        return 1;
    }

    size_t elements_read = fread(read_people, sizeof(Person), num_people, fp);
     if (elements_read != num_people) {
        fprintf(stderr, "Error reading array from file.\n");
        fclose(fp);
        return 1;
    }


    fclose(fp);

    printf("\nPeople data read from file:\n");
    for (int i = 0; i < num_people; i++) {
        printf("Name: %s, Age: %d\n", read_people[i].name, read_people[i].age);
    }

    return 0;
}

Explanation:

  • We define an array of `Person` structures.
  • We write the entire array to the file using `fwrite`. The `count` parameter is the number of elements in the array, `num_people`.
  • We read the entire array back from the file using `fread`. Again, the `count` parameter is the number of elements to read.
  • Error handling checks if the correct number of elements were written/read.

Handling Endianness

Endianness refers to the order in which bytes are stored in memory. There are two main types: Big-Endian (most significant byte first) and Little-Endian (least significant byte first). If you are writing binary files on one system and reading them on another system with a different endianness, you may encounter problems.

To handle endianness issues, you can use the following strategies:

  1. Network Byte Order: Convert all data to network byte order (Big-Endian) before writing to the file, and convert it back to the host byte order after reading from the file. Functions like htonl(), htons(), ntohl(), and ntohs() can be used for this purpose (found in <arpa/inet.h> on Linux/Unix systems). These functions convert between host byte order and network byte order for long (32-bit) and short (16-bit) integers. This only works for integer types.
  2. Platform-Specific Code: Include code that checks the endianness of the current system and performs byte swapping if necessary. This approach is more complex but gives you finer control.
  3. Standard File Formats: Use well-defined file formats that specify the byte order for data stored within the file. This is the best practice for long-term data portability.

Example (Network Byte Order):

 #include <stdio.h>
#include <arpa/inet.h> // For htonl and ntohl
#include <stdlib.h>

int main() {
    FILE *fp;
    unsigned long host_value = 1234567890;
    unsigned long network_value;

    // Convert to network byte order before writing
    network_value = htonl(host_value);

    fp = fopen("endian.bin", "wb");
    if (fp == NULL) {
        perror("Error opening file for writing");
        return 1;
    }

    size_t elements_written = fwrite(&network_value, sizeof(unsigned long), 1, fp);
    if (elements_written != 1) {
       fprintf(stderr, "Error writing to file\n");
       fclose(fp);
       return 1;
    }

    fclose(fp);
    printf("Value written in network byte order.\n");

    // Read back and convert to host byte order
    unsigned long read_network_value;
    unsigned long read_host_value;

    fp = fopen("endian.bin", "rb");
    if (fp == NULL) {
        perror("Error opening file for reading");
        return 1;
    }

    size_t elements_read = fread(&read_network_value, sizeof(unsigned long), 1, fp);
    if (elements_read != 1) {
       fprintf(stderr, "Error reading from file\n");
       fclose(fp);
       return 1;
    }

    fclose(fp);

    read_host_value = ntohl(read_network_value);
    printf("Value read and converted to host byte order: %lu\n", read_host_value);

    return 0;
}

Important Considerations for Endianness:

  • These functions (`htonl`, `ntohl`, etc.) are typically only applied to integers (short, int, long). They *cannot* be directly used with floating-point numbers or structures containing a mix of data types.
  • For floating-point numbers, the representation is more complex and platform-dependent. Serialization libraries or custom conversion routines may be needed for complete cross-platform compatibility.
  • When dealing with structures, you'll need to apply endianness conversion to each individual integer member of the structure. This can be tedious and error-prone, making the use of standard file formats or serialization libraries more appealing.

Error Handling

Robust error handling is essential when working with files. Always check the return values of fopen(), fread(), fwrite(), and fclose(). Use perror() to print system error messages to stderr.

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

int main() {
    FILE *fp = fopen("myfile.bin", "rb");
    if (fp == NULL) {
        perror("Error opening file");
        return 1;  // Indicate an error
    }

    // ... perform file operations ...

    if (fclose(fp) != 0) {
        perror("Error closing file");
        return 1;  // Indicate an error
    }

    return 0; // Indicate success
}

Example: Reading and Writing a Mix of Data Types

Here's an example that demonstrates reading and writing a structure containing a mix of data types (integer, float, and string) to a binary file.

 #include <stdio.h>
#include <stdlib.h>
#include <string.h>> // For strcpy

typedef struct {
    int id;
    float price;
    char description[100];
} Product;

int main() {
    FILE *fp;
    Product prod1 = {123, 99.99, "High-quality widget"};
    Product prod2;

    // Write to file
    fp = fopen("product.bin", "wb");
    if (fp == NULL) {
        perror("Error opening file for writing");
        return 1;
    }

    size_t elements_written = fwrite(&prod1, sizeof(Product), 1, fp);
    if(elements_written != 1){
        fprintf(stderr, "Error writing to file\n");
        fclose(fp);
        return 1;
    }
    fclose(fp);

    printf("Product data written to file.\n");

    // Read from file
    fp = fopen("product.bin", "rb");
    if (fp == NULL) {
        perror("Error opening file for reading");
        return 1;
    }

    size_t elements_read = fread(&prod2, sizeof(Product), 1, fp);

    if(elements_read != 1){
        fprintf(stderr, "Error reading from file\n");
        fclose(fp);
        return 1;
    }

    fclose(fp);

    printf("\nProduct data read from file:\n");
    printf("ID: %d\n", prod2.id);
    printf("Price: %.2f\n", prod2.price);
    printf("Description: %s\n", prod2.description);

    return 0;
}

Key takeaways:

  • Always use the binary mode ("rb", "wb", etc.) when working with binary files.
  • Use fread() to read data and fwrite() to write data.
  • Check the return values of file operations for errors.
  • Be aware of endianness issues when transferring binary files between systems.
  • Ensure that the structure definitions used for writing and reading are identical.
  • For portability and complex scenarios, consider using standard file formats or serialization libraries.
⬅ Previous Next ➡