TITLE: The Principle of Least Astonishment


PROBLEM: John Harechmak <johnrh@sgi.com>

Thanks for the reply! I thought about most of these issues before, but I have
a real hard time getting from there to why the X& should really be return
from ++X;


RESPONSE: clamage@Eng.Sun.COM (Steve Clamage), 11 Sep 95

The basic reason is that the predefined prefix ++ and -- result in lvalues.
(Notice that this is a difference from C.) According to the Principle of
Least Astonishment, user-defined operators should behave as much like the
predefined operators as possible. Consider this:
	foo(int&);
	foo(BigInt&);

	int x = ...;
	BigInt y ...;
	foo(++x); // OK, passes reference to x after incrementing x
	foo(++y); // is this OK?

If ++y doesn't behave like ++x, you, as the designer of BigInt, should set
aside a portion of each workday to answer questions from astonished users.

The C++ language rules allow any semantics and any return type for these
overloaded operators, but you do no one any favors by providing surprising
semantics or return types.

To ensure compatible behavior, the prefix ++ and -- should be member
functions (to prevent type conversion and creation of a temporary result),
and should return a non-const reference to the object:

	BigInt& BigInt::operator++() { ... return *this; }

Now suppose type X isn't numeric, and ++ doesn't really increment. IMHO,
you should not use the overloaded operator at all, because it probably does
not make the program easier to read or understand. Use a named function
instead, choosing a name that describes the purpose of the function.