bool operator ++ and --
ANSI ISO IEC 14882 2003 (c++03):
5.2.6-2
The operand of postfix -- is decremented analogously to the postfix ++ operator, except that the operand shall not be of type bool. [Note: For prefix increment and decrement, see 5.3.2. ]
And unsurprisingly...
5.3.2-2
The operand of prefix -- is modified by subtracting 1. The operand shall not be of type bool. The requirements on the operand of prefix -- and the properties of its result are otherwise the same as those of prefix ++. [Note: For postfix increment and decrement, see 5.2.6. ]
Also the 5.6.2-1 and 5.3.2-1 mention that ++ for bools shall be true and Annex D-1 says that ++ on bools in deprecated.
It comes from the history of using integer values as booleans.
If x
is an int
, but I am using it as a boolean as per if(x)...
then incrementing will mean that whatever its truth value before the operation, it will have a truth-value of true
after it (barring overflow).
However, it's impossible to predict the result of --
given knowledge only of the truth value of x
, as it could result in false
(if the integral value is 1) or true
(if the integral value is anything else - notably this includes 0 [false
] and 2 or more [true
]).
So as a short-hand ++
worked, and --
didn't.
++
is allowed on bools for compatibility with this, but its use is deprecated in the standard and it was removed in C++17.
This assumes that I only use x
as an boolean, meaning that overflow can't happen until I've done ++
often enough to cause an overflow on it's own. Even with char as the type used and CHAR_BITS
something low like 5, that's 32 times before this doesn't work any more (that's still argument enough for it being a bad practice, I'm not defending the practice, just explaining why it works) for a 32-bit int
we of course would have to use ++
2^32 times before this is an issue. With --
though it will only result in false
if I started with a value of 1 for true
, or started with 0 and used ++
precisely once before.
This is different if we start with a value that is just a few below 0. Indeed, in such a case we might want ++
to result in the false
value eventually such as in:
int x = -5;
while(++x)
doSomething(x);
However, this example treats x
as an int
everywhere except the conditional, so it's equivalent to:
int x = -5;
while(++x != 0)
doSomething(x);
Which is different to only using x
as a boolean.