C++ for Scientists - Technische Universität Dresden

3.7. ACCESSING OBJECT MEMBERS 81
Of course, the long form is almost never called but it illustrates that operators are regular
functions that only provide an extra syntax to call them.
Free functions allow qualifying the const-ness of each argument. Member functions do not even
mention the processed object in the signature. How const-ness can be specified then? There is
a special notation that notates the applicability of a member function to constant objects after
the function header, e.g. our subscript operator:
class vector
{
public:
const double& operator[](int i) const
{
assert(i >= 0 && i < my size);
return data[i];
}
};
The const attribute is not just a casual gesture of the programmer that he/she does not mind
calling this member function with a constant object. C ++ takes this constancy very seriously
and will verify that the function does not modify the object, i.e. some of its members, that the
object is only passed as const when free functions are called and that called member functions
have the const attribute as well.
This constancy guarantee also impedes returning non-constant pointers or references. One can
return constant pointers or references as well as objects. A returned object does not need to
be constant (but it could) because it is a copy of the object, of one of its member variables
(or constants), or of a temporary variable; and because it is a copy the object is guaranteed to
remain unchanged.
Constant member functions can be called for non-constant objects (because C ++ implicitly
converts non-constant references into constant references when necessary). Therefore, it is
often sufficient to provide only the constant member function. For instance a function that
returns the size of the vector:
class vector
{
public:
int size() const { return my size; }
// int size() { return my size; } // futile
};
The non-constant size function does the same as the constant one and is therefore useless.
For our subscript operator we need both the constant and the mutable version. If we only
had the constant member function, we could use it to read the elements of both constant and
mutable vectors but we could not modify the elements. By the way, our abandonned getters
should have been const since they are only used to read values regardless of whether the object
is constant or mutable.
3.7.4 Accessing multi-dimensional arrays
Let us assume that we have a simple matrix class like the following: