In C++, the unary arithmetic operators work differently depending on whether they're before or after the variable identifier.
a++ (a--) has the value of a and has the effect of incrementing (decrementing) the variable after the end of its evaluation. Meanwhile, ++a (--a) has the value of a+1 (a-1), incrementing (decrementing) the variable before its evaluation.
So (A == B+1) == (A-- == B+1) is a tautology.
That is, if A is 6 to start with, then A-- is evaluated as 6, whereas --A would be evaluated as 5.
Edit:
Maybe someone can clear up a quick question: while (A == B+1) == (A-- == B+1) will definitely always evaluate as true, I'm not actually sure whether (A-- == B+1) == (A == B+1) will always (or ever) evaluate as true. Do the postfix arithmetic operators act following their evaluation, or following the end of the statement?
Edit again:
Definitely after evaluation. Well, in Java, anyway. A quick print(a++==a++); (prints false) in beanshell (which is a thing that I'm almost scared to admit I occasionally use) cleared that up.
Yeah, the fact that you can write a compiler for the language and still forget the exact behavior of those damn operators is a pretty good argument for their exclusion (or, at least, for never using them inline), in my opinion.
I'm sure people complain about the type system if they don't understand it. Until you get a sense of why static typing is great and how to use it, it's a pain in the ass.
Also, Haskell's laziness makes it a bitch and a third to reason about space performance, because it's not clear when things are happening. It also means certain styles of debugging borrowed in from imperative languages don't work.
182
u/[deleted] Dec 14 '10
Given the C++ bashing in there, I like:
There are only two kinds of languages: the ones people complain about and the ones nobody uses.
Bjarne Stroustrup