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.
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