C++ for Scientists - Technische Universität Dresden

86 CHAPTER 3. CLASSES
of the decrement/increment we have the same symbol for two operators respectively that are
distinguished by the position.
To make a long story short, if we write i++ we must define the postfix increment:
single index operator++ (int)
{
single index tmp(∗this);
++i1;
return tmp;
}
We see that the operation requires an extra copy. The object itself must be incremented but
the returned valued must be still the old one. If we returned the object itself, i.e. ∗this, then we
had no possibility to increment it after the return. Therefore we need a copy before we modify
the object. Alternatively we could omit the copy and return a new object with the old value:
single index operator++ (int)
{
++i1;
return single index(i1 − 1);
}
This avoids the copy at the beginning but we still create a new object. These implementations
show that the postfix operators are somewhat more expensive than prefix operators; and this
true for all user-defined types. For C ++-own types the compiler can generate efficient executables
for both forms.
The really sad part of the story is that we put so much effort returning the old value of our
index and does not even use it. Therefore, we give the following
Advise
If you increment or decrement user-defined types prefer the prefix notation,
especially if the value of the changed variable is not used in the statement.
In the examples, we declared both indices as single index. It is sufficient doing this for the first
one and let the implicit constructor convert the second one:
A[single index(0), 1]
Unfortunately, we cannot write
A[0, 1]
The compiler will give an error message 11 like:
no match for ≫operator[]≪ in ≫A[(0, 0)]≪
To call operator[], the compiler would need to perform multiple steps that depend on each other:
first the zeros that are considered int would need to be converted to single index and then the
11 This is the message from GNU compiler.