C++ for Scientists - Technische Universität Dresden

84 CHAPTER 3. CLASSES
Approach 3: Returning proxies
Instead of returning a pointer we can build a specific type that keeps a reference to the matrix
and the row index and that provide an operator[] for accessing matrix entries. This proxy must
be therefore a friend of the matrix class to reach its private data. Alternatively, we can keep
the operator with the parentheses and call this one from the proxy. In both cases, we encounter
cyclic dependencies. 10
If we have several matrix types, each of them would need its own proxy. We would also need
different proxies for constant and mutable access respectively. In Section 6.5 we will show how
to write a proxy that works for all matrix types. The same templated proxy will handle constant
and mutable access. Fortunately, it even solves the problem of mutual dependencies. The only
minor flaw is that eventual errors cause lenghty compiler messages.
Approach 4: Multi-index type (advanced)
Preliminary note: this approach contains several new language features and discusses some
subtle details. If you do not understand the first time, don’t worry. If you like to skip it, do
it. That will not be a problem for understanding the rest of the book. But please read the
comparing discussion.
The fact that operator[] accepts only one argument does not necessarily mean that we cannot
give two. But we need a tricky technique to build one object out of two, without explicitly
constructing the object. The implementation is based on the matrix example from an onlinetutorial
[Sch].
First, we define a type:
struct double index
{
double index (int i1, int i2): i1 (i1), i2 (i2) {}
int i1, i2;
};
For this type we define the access operator:
double& operator[](double index i) { return data[i.i1∗ncols + i.i2]; }
const double& operator[](double index i) const { return data[i.i1∗ncols + i.i2]; }
Now we can write:
A[double index(1, 0)];
This works but it was not the concise notation we were looking for.
We introduce a second type:
struct single index
{
single index (int i1): i1 (i1) {}
double index operator, (single index j) const {
10 The dependencies cannot be resolved with forward declaration because we not only define references or
pointers but call member functions in the matrix and in the proxy. We will explain this in § ??.