C++ for Scientists - Technische Universität Dresden

3.7. ACCESSING OBJECT MEMBERS 85
};
}
return double index (i1, j.i1);
operator int() const { return i1; }
single index& operator++ () {
++i1; return ∗this;
}
int i1;
This new type overloaded the comma operator so that a second index creates a double index.
The constructor is implicit and the class contains an operator to int. This enables the compiler
to switch between single index and int in both ways.
This allows us to write code like:
or
single index i= 0, j= 1;
std::cout ≪ ”A[0, 1] is ” ≪ A[i, j] ≪ ’\n’;
for (single index i= 0; i < A.num rows(); ++i)
for (single index j= 0; j < A.num cols(); ++j)
std::cout ≪ ”A[” ≪ i ≪ ”, ” ≪ j ≪ ”] is ” ≪ A[i, j] ≪ ’\n’;
In the loop, an single index (i) is compared with an int (A.num rows()). This comparison operator
is not defined. The compiler converts i implicitly to an int and compares the values as int.
Thus, the conversion operator allows us to use all operations that are defined for int without
implementing them.
At this opportunity we can introduce another operator. C and C ++ provide a prefix and postfix
increment/decrement. The difference only manifests if we read the incremented/decremented
value, e.g., j= i++; is differs from j= ++i; by having the old value of i in j (in the first statement)
or the already incremented i (in the second statement). If the increment is the only expression
in the statement, e.g., i++; or ++i;, there is no semantic difference. Therefore, it does not
matter for loops whether we use the postfix or prefix notation.
for (single index i= 0; i < A.num rows(); ++i)
is (semantically) equivalent to:
for (single index i= 0; i < A.num rows(); i++)
For C ++ integer types it really does not matter. For user-defined types, the compiler will tell
us that this operation is not defined. The GNU Compiler emits the following error message:
no ≫operator++(int)≪ for suffix ≫++≪ declared, instead prefix operator tried
Fortunately, it already reveals the solution.
The operator++ without arguments is understood as prefix operator. To define a postfix operator
we must define it with a dummy int argument. This argument has no effect but we need
a way to define the symbol ++ as prefix and postfix operator. Unary operators are defined
as member functions without argument. This works for all other unary operators but in case