Binary Files in C++: Read Write Operations Tutorial

C++ streams have three state flags: fail, eof, and bad. When fail or bad bits are set, the stream stops functioning entirely - all read/write operations become no-ops. For string-to-integer conversion, you must check both the fail bit after reading and whether any extra characters remain after the integer. The extraction operator (>>) reads whitespace-separated tokens and returns the stream itself, which can be used as a boolean to check success. This enables concise error checking like 'if (cin >> result)'.

File I/O in C++ uses <fstream> library with ifstream for input and ofstream for output. Error handling relies on state flags: fail() for operation failures, eof() for end-of-file, bad() for non-recoverable errors, and good() for no errors. Always check if files opened successfully before operations. Files can be opened using explicit open() method or constructor. Modes include ios::in (read), ios::out (write), ios::app (append), ios::binary (binary data), ios::trunc (truncate), and ios::ate (move to end).

cerr is the C++ standard error stream, an output stream object oriented to narrow character set with external linkage and static duration. File error handling uses ferror() to check for errors (reading beyond EOF, non-existent files, unopened files, write-to-read-only files). Errors persist until file closure or clearerr() call. perror() displays error messages with optional user-defined prefixes, enabling programs to identify and respond to specific error conditions.

This section explains how to monitor and manage stream health in C++. Four state flags indicate stream conditions: good() confirms all is well, bad() signals unrecoverable errors, fail() detects logical operation failures (with badbit also set), and eof() marks end-of-file. The clear() function resets errors—without parameters it sets goodbit and clears others; with parameters it sets specific flags. rdstate() returns raw state values for bitwise manipulation, enabling selective flag clearing like clearing only failbit while preserving other states.

C++ file streams use an integer flag with four bits to track error states: bad bit (fatal errors), fail bit (non-fatal errors), good bit (no error), and eof bit (end of file reached). Fatal errors are serious and unrecoverable, such as when a file cannot be opened due to corruption or access issues. Non-fatal errors are recoverable, like reaching end of file or reading invalid data. C++ provides four functions to check these states: bad(), fail(), good(), and eof(). These functions return true when their respective bits are set, enabling developers to implement robust error handling in file operations.

Computers store all data in memory as characters, with each character occupying one byte (8 bits). There are four main number systems: Binary (base-2), Decimal (base-10), Octal (base-8), and Hexadecimal (base-16). Computers only recognize binary values (0 and 1), so human-readable text must be converted to binary for processing. This conversion is essential because computers cannot directly understand human language or symbols.

Computers store all data as binary numbers (bits). Text characters are stored as ASCII codes: 'D' is hex 44, 'i' is hex 69. Line breaks are represented by CR (hex 0D) and LF (hex 0A). Computers do not inherently understand letters, music, or images—they only work with binary numbers. The meaning of stored data is assigned through encoding standards like ASCII. This principle applies to all digital devices including smartphones, tablets, and embedded systems.

Data and information are fundamentally different: data are raw numbers or symbols without meaning, while information is processed data with context. For example, random ages are data, but calculating the average age from those ages produces information. Memory is organized like a beehive with numbered cells (addresses), where each cell stores bytes (8 bits). Each bit can only be 0 or 1. Memory addresses range from 10,001 to 10,007, with each address holding a byte of data.

Data storage involves two aspects: saving data in the system and formatting it. Memory consists of cells arranged in a continuous format, where each cell has a unique address. Data is stored in machine language (zeros and ones). Different data types occupy different memory sizes: characters take 1 byte, integers take 4 bytes, floats take 4 bytes, and doubles take approximately 16 bytes. This understanding is fundamental to grasping how data structures work at the hardware level.

This section covers computer memory architecture and data representation formats. All computer information is encoded in binary because electronic circuits can only distinguish two states (signal present or absent). Memory is divided into bytes (8 bits each), with each byte representing a physical memory element. Software must interpret binary data differently based on purpose: text editors interpret as character codes, graphics systems as pixel data, and computational programs as hexadecimal digits. Memory is classified into three types: register memory (within CPU for immediate processing), internal memory (RAM for current operations), and external memory (magnetic disks, tapes, CD-ROMs for long-term storage). Fixed-point format stores numbers with a fixed decimal point position, with bytes allocated by application software. Positive numbers are encoded directly in binary, while negative numbers use two's complement: invert all bits of the absolute value, then add 1. Floating-point format represents real numbers with a sign bit, exponent, and mantissa. The format is normalized so the mantissa is between 0.1 and 1 (decimal) or 0.5 and 1 (binary). Text information uses 2 bytes per character: the first byte contains the character code, and the second byte contains color attributes for the character cell (64 pixels).

Text files use line ending conventions derived from mechanical typewriters: line feed (LF) advances paper one line, carriage return (CR) moves carriage back to start. Windows uses CRLF (13+10), Unix/Linux uses LF only (10), and classic Mac OS used CR only. When reading files, text mode applies OS conversions while binary mode returns raw bytes. Characters are stored as bytes using encodings like UTF-8, where each character may require multiple bytes. This distinction between strings (text) and bytes (binary) is fundamental in programming.

CRLF (Carriage Return + Line Feed) represents the historical mechanical process of moving paper in typewriters and printers, where the carriage would return to the left margin and then feed the paper down for a new line; modern operating systems use different line ending conventions—Windows uses CRLF (ASCII 13+10), Linux uses only LF (ASCII 10), and Mac traditionally used CR (ASCII 13)—which can cause issues when transferring text files between systems, though Git's autocrlf setting and modern code editors help manage these differences automatically.

Unix-based systems (Linux, Mac OS) use only the line feed character (LF, 0x0A) to end lines, while Windows uses both carriage return and line feed (CRLF, 0x0D 0x0A). This difference originated from Unix's evolution from Multics, which introduced device drivers that converted LF to CRLF for teleprinters, while Windows evolved from MS-DOS which lacked device drivers.

When developers work across Windows and Linux/Mac operating systems, Git throws warnings about replacing LF (Line Feed) with CRLF (Carriage Return + Line Feed) because these OSs handle line breaks differently; this can be resolved either by configuring individual user settings with 'git config --global core.autocrlf true' for Windows or 'git config --global core.autocrlf input' for Unix/Mac, or by creating a global .gitattributes file in the project root that specifies text file handling rules (e.g., '* text=auto') and excludes binary files (e.g., '*.jpg binary'), then running 'git add --all' and 'git checkout --force' to apply the changes consistently across the entire codebase.

Line breaks in computing involve distinct ASCII control codes: Carriage Return (CR, 13) moves the print head to the line start, while Line Feed (LF, 10) advances paper upward. Together, they created new lines on mechanical teleprinters, enabling effects like bold text through overprinting. Unix-based systems (Linux, macOS) use single LF characters, while Windows requires both CR and LF (CRLF) for compatibility with older systems dating back to CP/M and MS-DOS. This divergence illustrates how operating system lineage determines file format standards, creating ongoing interoperability challenges across platforms.