Overloading Operators in C++

The << operator already knows how to write the built-in types, such as numbers and strings, to an output stream like cout. Once you define your own data type, that knowledge no longer covers it. The built-in output operator has no meaningful default for a user-defined type, so writing that type directly to a stream does not produce a useful result.

A custom output operator solves this problem. It is a function that teaches the << operator how to write your new type in a format you choose. Once it exists, a value of that type can be written in an ordinary output statement, exactly as a built-in type would be written.

Throughout this article we use a struct called Entry. It holds two members: a string called name and an int called number. Grouping a name with a number like this is a common reason to need a custom output format, because the struct has no printed form of its own.

The goal of the operator is to write an Entry in a format that resembles the brace notation used to initialize it in code. The name appears in quotation marks, followed by the number, all inside braces. The body of the operator is what fixes this printed format, so every string literal and member access in it contributes to the final text.

The standard form of the signature is ostream& operator<<(ostream& os, const T& obj), where T stands for the user-defined type. Every part of this line has a job. The keyword operator together with << tells the compiler that this function overloads the << operator. The return type ostream& gives back a stream, and the first parameter ostream& os is the stream the value will be written to.

The second parameter, const T& obj, is the value being written. It is passed by constant reference, which means the object is not copied and the operator cannot modify it. For the Entry struct, T is simply Entry, so the parameter becomes const Entry& e.

The stream parameter is taken by reference. This means the operator writes to the original stream, not to a copy of it. When the operator finishes, it returns that same stream. Because the return type ostream& matches the first parameter, the result of one << call is a stream that can serve as the left operand of the next << in the same expression.

Read the body of the operator from left to right, the same way the output is produced. The first piece, written by os << "{\"", sends an opening brace and a quotation mark to the stream. Next, e.name writes the name. The closing quotation mark, a comma, and a space follow. Then e.number is written, and finally a closing brace.

A statement such as cout << e << endl is not a single action. It is a sequence of operator calls. The first call takes cout as its left operand and e as its right operand. Because the operator returns the stream, the result of that first call becomes the left operand of the next << in the chain.

When cout << e runs, the call goes to your operator, not to a built-in routine that handles structs. The operator receives cout by reference and e by constant reference. Each << inside its body then writes one piece to that same stream. The characters appear in order, and only after the body finishes does control return to the caller with the stream.

The mistakes below all involve the signature or the return value. Each one breaks a part of the design that the source describes: the stream is received by reference, the same stream is returned, and the returned stream feeds the next << in the chain.