How to create a binary file in C?

Creating a binary file in C language is very simple, requiring only some specific functions to be implemented. There are also other binary modes: read, and write, which will be discussed further in this article.

Binary files match arrays of structures extremely closely, with the difference that the structures are stored in a disc file rather than an array in memory. Since they are stored on a disc, you may build extensive collections of the structures in a binary file. Additionally, they are constant and readily available. The slowness caused by disc access time is a significant drawback.

What is a binary file?

A binary file is a type of file with a specific format known as binary, consisting of a series of bytes that are sequential and each eight bits long. The information needs to be interpreted by a software program or hardware processor that knows how it is formatted and how to read the data in advance.

Many different kinds of file that can be stored as binary files are executables, libraries, images, databases, files, and others. The point to be noted here is that it requires a specialized software program or hardware processor that is capable of reading the file's data. Only then can the binary content's instructions be correctly decoded and processed.

Typically, binary files and text files are the two types of electronic files. Since text files are composed of sequences of bytes like all other electronic files. The two, however, are widely considered to belong to different types.

Importance

• When a program is stopped, all of the data is lost. If you store your data in a file, it will be retained even if the program is terminated.
• If there are many of them, entering all the data will take a while. However, using a few C commands, you can easily retrieve the data if you have a file with all the information in it.
• You may quickly move your data from one machine to another without making any changes. The complete set of data is lost when a program is stopped.
• Binary data allows for significantly faster input and output. It takes some time to convert a 32-bit number to characters. Not a lot of time, but the total conversion time increases if a file (such as an image file) has millions of numbers. If data were kept in character form, computer games would bog down.
• A binary file often has a considerably smaller file size than a text file with the same amount of data. This is crucial for audio, video, and image data. Small files take up less storage, can be transferred more quickly, and are processed faster. Since there are lesser bytes to share, I/O with smaller files is also quicker.
• Certain types of data are difficult to represent as characters. For instance, the machine language of an executable file or the bytecodes of a file. Although you would not typically consider this to be data, it certainly is.
• Additionally, there is no need to make the individual data samples human-readable because humans hardly ever analyze them. Humans, for instance, view the overall image in a GIF file and are not very interested in viewing the individual pixels as numbers. A programmer or scientist may occasionally need to perform this for scientific or debugging purposes.

Difference between text files and binary files

In binary files, a structure's contents are always editable. Any structure in the file can be accessed immediately, offering random access similar to that of an array.

The file-of-structures approach is very well supported in C. You can read, write to, or seek to any structure in the file after it has been opened. The idea of a file pointer is supported by this file concept. The pointer points to record 0 when the file is initially opened. Any read operation advances the pointer down one structure and reads the structure that is presently pointing to. Any write operation shifts the pointer down one structure and writes to the structure that is currently being referenced to. The pointer is moved to the specified record by seeking.

Because a binary image of the record is stored directly from memory to disc, binary files typically have faster read and write times than text files.

A text file is meant to be readable and understandable by humans. This used to mean good old ASCII but now includes other human-language character sets as well. It even includes things like HTML or XML, which are often human-readable by a very generous definition. You can still open them in a text editor, they'll display sensibly, and you can see something reasonably meaningful. Binary is anything else. All files are ultimately stored in binary form.

There's actually a particular context in which "text" and "binary" actually mean something similar and are distinct from anything else. A compiled program, as distinct from its source code or data files, is called a binary. If you use the right tools to peek inside a binary, you'll find that one of the segments is called "text", meaning that it's the main piece of executable code - not libraries, data, etc. This same terminology repeats inside the kernel, which uses this information to load the various pieces of the program into memory. In this linker/loader context, "text" is part of a "binary", and "binary" refers to a specific kind of file.

How do they work?

When it comes to files, binary has two widely used definitions.

1. The file is executable.

2. It cannot be read by humans

For (1), the executable likely has a particular format that any operating system "loader" mechanism can understand. In order to launch the program, the OS loader must first read it from the disc, allocate and copy the necessary bytes to memory, and then spawn a process. Additionally, libraries may need to be loaded dynamically.

For (2), those bytes' meaning was determined by someone somewhere. It might be as complex as an official standard like MP3 or as simple as a coder sending a few bytes to the file, and only by reading the code can it be understood.

In binary file, there are 4 operations

1. Create a file

2. Open an already existing file

3. Closing a file

4. Reading information from a file

5. Writing information to a file

Before moving on to binary files creation, there are some file modes that has to be known to work with them.

rb: A binary file is opened in read mode

wb: A binary file is opened in write mode

ab: A binary file is opened in append mode.

rb+: A binary file is opened in read-write mode.

wb+: A binary file is opened in read-write mode.

ab+: A binary file is opened in read-write mode.

NOTE: It's important to know that  fread and fwrite functions take four parameters as input:

• A memory address
• Number of bytes to read
• Number of blocks
• A file variable

Program to create a binary file in C

#include<stdio.h>
int main()
{
    /* Create a new file */
    int a = 5;
    FILE *fp = fopen ("myfile.bin", "wb");
    if (fp == NULL)
      return -1;
    fwrite (&a, sizeof (a), 1, fp);
    fclose (fp);


    return 0;
}

Program to read a binary file in C

#include <stdio.h>
#include <ctype.h>


int main() {
    FILE *fp;
    struct marks {
        char name[50];
        int age;
        float percentage;
    } m;
    fp = fopen("myfile.bin", "rb");
    if (fp == NULL) {
        puts("Couldn’t able to open this file.");
        return 1;
    }
    while (fread(&m, sizeof(m), 1, fp) == 1) {
        printf("\n%s \t %d \t $%.2f\n", m.name, m.age, m.percentage);
    }
    fclose(fp);
    return 0;
}

Program to write a binary file in C

#include <stdio.h>


int main()
{
    FILE *fp;
    struct marks {
        char name[50];
        int age;
        float percentage;
    } m;
     fp = fopen("myfile.bin", "wb");
    if (fp == NULL)
    {
        puts("Couldn’t able to open this file.");.");
        return 1;
    }
   
        m.name=”Varshith”;
        m.age=19;
        m.percentage=98.9;
        fwrite(&m, sizeof(m), 1, fp);
    fclose(fp);
    return 0;
}  

Some problems with the binary files

A software can check for valid input values if the expected range of values for the data is known. Sometimes, additional information about the data can be used to prevent it. However, if not, there is typically no way to check. It's common for bytes written in one format to be wrongly read in by another. You must confirm that the software and the data file are compatible.

This is a typical programming issue. Some files dated back many years and were produced using ill-documented software on outdated systems. It frequently takes some hard work to figure out how to understand them.

A file usually has a header that describes its contents. For instance, picture files frequently use this. When reading a file, a program examines the header to make sure it is what is expected. It is typical for the header to contain extra details like the time it was made and the software version that created it, among other things.

Also, knowing the header's format is now necessary, which could provide another issue. Many file headers begin with a few bytes of code that describe the format that the file's remaining bytes will take. GIF picture files, etc.

Conclusion

Up to this point, we have discussed about binary files, their importance, the difference between text and binary files, their usage and how to create a binary file, how to read a binary file, how to write to a binary file and various other modes.