C++ for Scientists - Technische Universität Dresden

3.7. ACCESSING OBJECT MEMBERS 87
comma operator has to be applied on them. A language that would allow such dependent
conversions would end up in extremely long compile times to considered all possibilities 12 and
probability of ambiguities would increase tremendously.
Instead the compiler considers ‘0, 0’ as a sequence of two expressions where each expression is
an integer constant. The result of a sequence is the result of the last expression, i.e. the integer
constant zero in our case. This cannot be converted into a double index.
To throw in a really bad idea, we give the second constructor argument of double index a default
value:
struct double index
{
double index (int i1, int i2= 0) // Very bad
: i1 (i1), i2 (i2) {}
int i1, i2;
};
Then the expression A[0, 1] compiles, as well as A[0, 1, 2, 3, 4]. It evaluates the integer sequence
and the result is the last expression. A single integer can be implicitly converted into double index.
As a result, the last integer is considered the row and the column is zero.
Comparing the approaches
The previous implementations show that C ++ allows us to provide different notations for userdefined
types and we can implement it in the manner that seems most appropriate to us. The
first approach was replacing square brackets by round parentheses to enable multiple arguments.
This was the simplest solution and if one is willing to accept this syntax, one can safe oneself
the length we went through to come up with a fancier notation. The technique of returning a
pointer was not complicated either but it relies to strongly on the internal representation. If
we use some internal blocking or some other specialized internal storage scheme, we will need
an entirely different technique. Another drawback was that we cannot test the range of the
column index.
The last approach, introduced special types and the fact that we must always specify the type
of the index explicitly makes the notation for constant indices clumsier instead of clearer. It
also introduced a lot of implicit conversions and in a large code base we might have enormous
trouble to avoid ambiguities. Another unfortunate aspect is the overloading of the comma
operator. It makes the understanding of programs more difficult — because one has to pay a
lot of attention to the types of expressions to distinguish it from non-overloaded sequences —
and can cause weird affects. Thus, our first recommendation is keep reading since the proxy
solution in § ?? is in our opinion preferable to the previous approaches (although not perfect
either).
Resuming, C ++ gives us the opportunity to handle programming tasks in different ways. Several
times, none of the solutions will be perfect. Even if oneself is satisfied with the solution,
then there will be most certainly some (allegedly) experienced C ++ programmer who finds a
disadvantage.
12 It might even become undecidable.