c++ How to Read Binary Files in C++

[Linux Hint]

In this article, we will learn about reading a binary file in C++. The concept of reading the binary file means reading the raw bytes of the file instead of the data inside the file. In C++, there are many ways and methods through which we can read any type of file like binary files, text files, pdf files, and many more. This programming language uses the stream for file processing to achieve these tasks. Here, we will learn about the reading operation of binary files using a stream-based library. We will explore how to read a binary file with proper examples.

What Is a Binary File in C++?

A binary file is a file in C++ that always stores the data that is not in an easily understandable format for humans. Only computer reads the binary data; binary means data in the sequence of “0,1” or ASCII format. It contains the encrypted data. Humans cannot understand this type of file, and only computers can operate with this type of binary file. The primary operator reads the raw binary data in C++ and handles the data at the binary level. So, these file manipulations are very complex for humans. Dealing with this type of file is such a complicated or complex task in the programming world.

The standard libraries that are used to read the binary file in C++ are file stream classes such as “ifstream” and “ofstream” from the main <fstream> stream header.  We use the “ifstream” library to read a binary file. We open the binary file using the flag which is “ios::binary”. The binary file opening is a must to ensure that the data is read in its binary format. Handling the binary files requires a very careful consideration of data types and file structures.

Importance of Binary File in C++

The binary file plays a vital role in handling the file processing in C++. The binary file requires a critical approach in gaining the appropriate storage of data and their retrieval. The binary files facilitate us in the programming world in different ways:

Data Integrity

The binary files store the data or information byte by byte without any further occupation of formatting and additional interpretation. It also overcomes the risk of a sudden data corruption event. The integrity of binary files is retained in this proper way.

More Efficient

The binary files are more efficient and valuable in terms of file storage. This file’s data is in numeric storage like IEEE or 5765 instead of long characters or text. The data is in encrypted form, so the speed of this file is fast and more efficient for handling the essential data.

Compatibility

Due to the consistency and accessible comprehension of binary data representation, users are encouraged to use the binary files for compatibility across various environment platforms and programming languages.

In Which Scenario should We Read the Binary Files?

Let’s take a quick example to learn about the read action of binary files in proper programs. These examples help us discover more emerging techniques for handling the binary files in the C++ programming language.

Scenario 1: Read the Binary Files Using the Read() Function along with Ifstream

In C++, we can read the binary files using the streams and different methods to store or transfer the data in different locations. In this scenario, we will learn how to read a binary file in C++ easily by just calling the “if” stream and “read” function with the help of standard libraries. The code snippet of this scenario is mentioned in the following for better understanding:

#include <iostream>
#include <fstream>
int main() {
    std::ifstream file("binaryData.bin", std::ios::binary);
    if (file.is_open()) {
        char buffer[200]; //buffer is used to store temporary data
        file.read(buffer, sizeof(buffer));
       std::cout<<"File Open Successfully";
    } else {
        std::cout << "Unable to open file";
    }
    return 0;
}

 
In this code snippet, we open a binary file that is already created in our system, and the text data is stored there. The binary file contains an encrypted data, so the visualization of this type of data is challenging. After declaring the valid utilities or libraries, we use a stream file handling in the main function using the “std:: ifstream file()” method. We pass the “address of the file that needs to be read” and “type of file in binary format std::ios:binary” in this file function.

After that, we implement the condition if the address and format of the file are correct. Then, we open the file. Otherwise, we show the error on the console window.  Ensure that the given file exists in your system, and the address is correct. At the end, run the code, and the console window that has the output opens.

The output screen shows that the binary file is open and the content is read. The content can be displayed on the screen because the data is not in a text format.

Scenario 2:  Read the Binary File Using the Fread() Method

In this scenario, we will learn how to read the binary file data using the fread() method.  The fread() function reads the data of files in blocks from the stream. We use another way to open a binary file using the “FILE” pointer.  Let’s take an example of this scenario with a proper code snippet that is attached in the following:

#include <stdio.h>
#include <iostream>
#include <fstream>
int main() {
    FILE *file = fopen("binaryData.bin", "rb");
    if (file != NULL) {
        char buffer_arr[100];
        fread(buffer_arr, sizeof(char), sizeof(buffer_arr), file);
       std::cout<<"Read Successfully.....Binary File is read through fread()";
        fclose(file);
    } else {
        std::cout<<("Unable to open file");
    }
    return 0;
}

 
Here, we add libraries like <iostream> and <fstream> which are a must for file stream and output purposes. In the main function, open a file using the “fopen()” method and pass the binary file address with the “.bin” extension and the read mode. Initialize fopen() to a “file” pointer since we know that the pointer stores the data in the buffer. After that, check if the file is opened or not. If the file is not null, we read a file using fread(). Otherwise, we show the error that the file is not opened. We compile this code in your Dev C++ environment and generate a result on the following console screen:

The given output screenshot shows that the file is opened and read successfully.

Conclusion

Finally, we can say that binary files are complicated files that are not understandable for humans, and the data inside these files are also encrypted and not in visible format. Here, we discussed in detail about the “read” mode of binary files. Remember that the extension of binary files must be in “.bin”, and the methods to read a binary file must be valid and defined. Here, we mentioned some best examples for understanding the concept more clearly and concisely. Practice these code snippets in your environment to understand the core concepts better.

View the full article