The prefix and postfix versions of the increment and decrement operators can all be overloaded. We will see how the compiler distinguishes between the prefix version and the postfix version of an increment or decrement operator.
To overload the increment operator to allow both prefix and postfix increment usage, each overloaded operator function must have a distinct signature, so that the compiler will be able to determine which version of ++ is intended. The prefix versions are overloaded exactly as any other prefix unary operator would be.
Overloading the Prefix Increment Operator
Suppose, for example, that we want to add 1 to the day in Date object d1. When the compiler sees the preincrementing expression ++d1, the compiler generates the member-function call
The prototype for this operator function would be
If the prefix increment operator is implemented as a global function, then, when the compiler sees the expression ++d1, the compiler generates the function call
operator++( d1 )
The prototype for this operator function would be declared in the Date class as
Date &operator++( Date & );
Overloading the Postfix Increment Operator
Overloading the postfix increment operator presents a challenge, because the compiler must be able to distinguish between the signatures of the overloaded prefix and postfix increment operator functions. The convention that has been adopted in C++ is that, when the compiler sees the postincrementing expression d1++, it generates the member-function call
d1.operator++( 0 )
The prototype for this function is
Date operator++( int )
The argument 0 is strictly a "dummy value" that enables the compiler to distinguish between the prefix and postfix increment operator functions.
If the postfix increment is implemented as a global function, then, when the compiler sees the expression d1++, the compiler generates the function call
operator++( d1, 0 )
The prototype for this function would be
Date operator++( Date &, int );
Once again, the 0 argument is used by the compiler to distinguish between the prefix and postfix increment operators implemented as global functions. Note that the postfix increment operator returns Date objects by value, whereas the prefix increment operator returns Date objects by reference, because the postfix increment operator typically returns a temporary object that contains the original value of the object before the increment occurred. C++ treats such objects as rvalues, which cannot be used on the left side of an assignment. The prefix increment operator returns the actual incremented object with its new value. Such an object can be used as an lvalue in a continuing expression.
Performance Tip 11.3
The extra object that is created by the postfix increment (or decrement) operator can result in a significant performance problemespecially when the operator is used in a loop. For this reason, you should use the postfix increment (or decrement) operator only when the logic of the program requires postincremnting (or postdecrementing).
Everything stated in this section for overloading prefix and postfix increment operators applies to overloading predecrement and postdecrement operators. Next, we examine a Date class with overloaded prefix and postfix increment operators.