Custom Input and Output Operators for User-Defined Types

When a program reads input from a stream, the characters it receives are not always the ones it expects. Spaces, tabs, and newlines are all whitespace, and whether they get consumed or left in the stream depends on which input operation you use. Two operations that look almost identical can return different results for the same input. This article focuses on that difference, because it determines what your program actually sees when it reads a value.

The source introduces this idea in the context of user-defined types. When you write your own input operation, you decide how it reads from the stream. You must also know how the built-in operators behave, so that your code makes the same choices deliberately rather than by accident.

Imagine a stream whose first two characters are spaces, followed by the letter x. You want to read a single character from it into a variable named c. Before reading the explanation, make a prediction: which character will end up in c when you use the is>>c form, and which will end up in c when you use the is.get(c) form?

The is>>c input operator skips whitespace by default, so it stores the first non-whitespace character it finds. The read position starts at the beginning of the stream. The operator moves past every space, tab, or newline it encounters. As soon as it reaches a character that is not whitespace, it stores that character in c. In the two-space example, the read position moves past both spaces, reaches x, and stores x.

The diagram above traces the read from start to finish. The whitespace is consumed, not stored. The operator does not hand you the spaces at all, which is why the variable holds a visible letter rather than a blank.

Formatted input is designed to read values that are separated by spacing and line breaks. Because is>>c skips whitespace by default, you can lay out your input across lines or add extra spaces between values without changing what the program reads. The operator treats whitespace as separation rather than as data, so the value you care about is the first real character it meets.

The is.get(c) form is the contrasting case. It does not skip whitespace. It starts reading exactly at the current position, so it stores whatever character is next in the stream, including a space. Using the same two-space stream, the first character is a space, and is.get(c) stores that space rather than the x.

The source describes an Entry input operator, a user-defined input operation for a type that holds a name. Its whitespace rule is specific: it ignores whitespace outside its name string, but it does not ignore whitespace within that string. In other words, spaces that surround the name are discarded as separators, while spaces that belong to the name itself are kept as part of the name.

Reading one character at a time works when you know exactly what each position should contain. When you need to recognize a pattern across a stream of characters, the source points to a more systematic technique, regular expression matching. The source covers it in a later section and mentions it only as a pointer, so this article does not describe how it works.

For now, the useful takeaway is that character-by-character reading, with its whitespace rules, is the foundation that a pattern-recognition technique would build on. Understanding exactly which characters are consumed and which are stored is what makes later pattern work predictable.