Reading and Writing Binary Files with `fread()` and `fwrite()`

1. Text vs. Binary Files: The "Why"

Before we jump into the code, it's crucial to understand the difference between the text files we used in the last lesson and the binary files we'll use today.

• Text Files: Store data as a sequence of human-readable characters. When you save the number 123, you are actually storing the characters '1', '2', and '3'. The fprintf and fscanf functions handle the conversion between the in-memory representation of the number and its character-based representation.
• Binary Files: Store data as a direct, byte-for-byte copy of its in-memory representation. The integer 123 is stored as the specific four bytes (on most systems) that represent that number in memory. There is no conversion.

To dig a little deeper into this distinction, please review the following material.

The key takeaway is that binary files are more compact and faster to process because the program doesn't need to perform expensive string-to-number (and vice-versa) conversions. This makes them ideal for saving the state of an application or logging raw data for later analysis. The trade-off is that the files are no longer human-readable.

2. Writing Binary Data with fwrite()

The function for writing binary data is fwrite(). Its prototype looks like this:

size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);

Let's break down its arguments:

• ptr: A pointer to the data you want to write.
• size: The size, in bytes, of a single element you are writing. You'll almost always use the sizeof() operator here (e.g., sizeof(int), sizeof(struct Point)).
• count: The number of elements you want to write. To write a single int, this is 1. To write an array of 10 ints, this is 10.
• stream: The FILE * handle returned by fopen(), opened in a binary write mode like "wb" (write binary) or "ab" (append binary).

fwrite() returns the number of elements successfully written. It's crucial to check this return value to ensure your data was saved correctly.

The following video provides a practical demonstration of writing a simple struct to a binary file.

3. A Complete Example: fwrite() and fread() with an Array of Structs

Now let's tackle a more comprehensive and realistic scenario: saving an entire array of structs to a file and then reading it back. This is a common pattern for persisting collections of data.

The function for reading binary data is fread(), and its signature is a mirror of fwrite():

size_t fread(void *ptr, size_t size, size_t count, FILE *stream);

Here, ptr is a pointer to the memory location where you want to store the data read from the file.

The next video is an excellent, complete walkthrough of a program that defines write_data and read_data functions for an array of student structs. It also introduces a clever technique: writing the number of records at the beginning of the file, so you know how much memory to allocate when you read it back.

This video demonstrates a robust pattern for data persistence that you can adapt for your own projects. The combination of writing metadata (the count) along with the data itself is a powerful technique.

4. Portability Caveats: Endianness and Padding

Your experience with Python and Java may have led you to expect data files to be universally portable. With C binary files, that's not always the case. Writing a raw memory dump is fast and efficient, but it exposes you to two "under the hood" hardware details: endianness and struct padding.

Endianness

This refers to the order in which a computer architecture stores the bytes of a multi-byte data type (like an int or float).

• Little-endian (e.g., Intel/AMD CPUs) stores the least significant byte first.
• Big-endian (e.g., many network protocols, older CPUs) stores the most significant byte first.

If you fwrite an int on a little-endian machine and fread it on a big-endian one, you will read a completely different number.

Structure Padding

Compilers often insert invisible, empty bytes into structs to align data members on memory addresses that are optimal for the CPU to access. This is called padding. The result is that sizeof(struct) can be greater than the sum of the sizes of its members.

If you compile your code with two different compilers (or on different systems) that use different padding rules, a binary file written by one program will not be readable by the other.

For your goals of building desktop applications and working with Arduino (which often uses ARM-based processors), these issues are important to be aware of. If you are only ever reading and writing files on the same machine, you don't need to worry. But if you need to exchange binary data between different systems, you must use a standardized format (like network byte order) or a serialization library that handles these differences for you.

Conclusion

In this lesson, you've moved beyond text files and learned how to persist data in a much more efficient, machine-native format. This skill is a cornerstone of performance-oriented programming in C/C++.

Key Takeaways:

• Binary files store a raw memory dump of data, which is faster and more space-efficient than text files because it avoids data conversion.
• Files must be opened in a binary mode (e.g., "wb", "rb") for binary I/O.
• fwrite() writes one or more elements from a memory buffer to a file.
• fread() reads one or more elements from a file into a memory buffer.
• A common and robust pattern is to write the number of records to the file first, followed by the records themselves.
• Binary files are not always portable across different computer architectures due to issues like endianness and struct padding.

Next Up

We've now explored file I/O for both text and binary formats. In the next lesson, we will shift our focus back to the compilation process itself and explore the C preprocessor. You will learn how to use preprocessor directives for defining constants (#define) and for conditional compilation (#ifdef, #if). This is a key tool for writing clean, configurable, and cross-platform code.