14.7. Character I/O

It is often useful to process (read and write) the contents of a file one character or one byte at a time. The three I/O functions demonstrated in the mycopy.cpp example are sufficient for completing these tasks. Furthermore, these functions work with both textual and binary data. Four additional "support" functions, also illustrated in mycopy, provide everything else needed for the task. Three of the functions, eof, good, and operator(), were described in detail previously. While operator>> and operator<< can be used to read and write textual data, they should be avoided when processing binary data because their behavior varies between systems.

int get();

istream& get(char& c);

ostream& put(char c);

streamsize gcount();

Common Programming Patterns

ifstream input("input.txt");
ofstream output("output.txt);

int c;
while ((c = input.get()) != EOF)
{
	// process c
	output.put(c);
}

char c;
while (input.get(c))
{
	// process c
	output.put(c);
}

int c = input.get();
do
{
	// process the data
	c = input.get();
} while (! input.eof());

int c = input.get();
do
{
	// process the data
	c = input.get();
} while (input);

int c = input.get();
while (input.gcount() > 0)
{
	// process c
	output.put(c);
	c = input.get();
}

Binary Data

The code fragment presented in Figure 2(b) raises the last question about character I/O that we must answer. The get function reads and returns a single character or byte from a file. In the code fragment, the byte is first stored in a variable and then compared to the value represented by the symbolic constant EOF, typically -1. This code pattern was one of two used in the mycopy example to read the contents of a binary file. If a binary file can contain any value, positive or negative, why doesn't the loop end when the program reads a data value of -1 from the file?

The answer lies in how computers store negative values in main memory and disk files. Each byte of data consists of 8-bits, which means there are 2⁸ = 256 possible patterns of 1s and 0s. Two keywords, signed (able to store 0, positive, and negative values) and unsigned (only able to store 0 and positive values) modify how the bit-patterns are interpreted. C++ treats most integers as signed by default, but it is left to the underlying hardware to determine if characters are signed or unsigned by default (typically signed on contemporary hardware).

Since we can't store a "-" sign in a byte, some bit patterns must be interpreted as negative values. The left-most bit, called the sign bit, indicates the sign of a signed value (0 = positive and 1 = negative), but it is included with the magnitude of an unsigned value. The key to understanding the behavior of the get function is appreciating that digital computers store all machine instructions and data as 1s and 0s, which are meaningless until they are grouped together and interpreted. In the case of data, the same bit pattern may be interpreted in more than one way. That is, data can be written as a signed value but read as an unsigned value.