To be succinct, I believe this dates from older compilers where a
post-increment operation was more expensive than pre-increment, but the
equivalence of the two (in any sane environment) means that modern
compilers should be able to optimize the two to the same thing in this
environment.
I code in C++ as well as Java, it is true in C++ because classes can
have their own pre- and post- increment operators.
I can make the && operator in C++ perform multidimensional matrix
inversion if I wish, but that operation will most likely confuse anyone
who uses it. Justifying a tradition on the basis of what a user *may*
do, especially if such actions require defying conventional logic.
> I like to maintain
the habit whatever one of the C-style languages I am using. I agree
it is less important in Java where you cannot add operators to
classes. Think of the work needed to pre-increment or post-increment
a BigInteger.
I've not decided how I would like to see operator overloading
implemented in Java. Personally, I think an
interface+implementation+generics model works best (although getting an
int * BigInteger operator is not going to be intuitive), but the
annotation model also has its strong points.
In any case, based on some of my experiences in the GCC world, I think
using annotations to specify compiler hints would be useful here.
Hypothetically speaking:
interface Incrementor<T> {
// ++obj -> obj.preIncrement();
T preIncrement();
// obj++ -> obj.postIncrement();
// I'm not quite happy with this model
T postIncrement();
}
public class BigInteger implements Incrementor<BigInteger> {
public BigInteger preIncrement() {
// increment self
return this;
}
@IfIgnored("preIncrement")
public BigInteger postIncrement() {
BigInteger ret = new BigInteger(this);
// increment self
return ret;
}
}
The annotation IfIgnored tells the compiler that if the return value is
ignored, the method is equivalent in function to preIncrement. Sure,
strong powers of abuse, but if operator overloading is implemented in
any case, there's already strong temptations for abuse anyways.
