如何从成员函数（通常）返回常量（返回到成员数据）返回常量

Question

I'm writing a classes for lower/upper triangular matrices (of double s). By taking advantage of the fact that an n*n triangular matrix only has n*(n + 1)/2 [potentially nonzero] elements, internally I'm storing only that amount of elements, in a flat array member.

First of all, I have a base class for "normal" (ie dense) matrices, with operator() as a subscript operator that takes the row index and the column index:

class Matrix {
public:
    // [...]
    virtual const double &operator()(unsigned i, unsigned j);
    virtual double &operator()(unsigned i, unsigned j);
    // [...]

private:
    std::valarray<double> data_;
    std::size_t size_;
}

// [...]
const double &Matrix::operator()(unsigned i, unsigned j) {
    return data_[size_*i + j];
}

For triangular matrices (I'll take lower triangular matrices henceforth as an example), in order to provide the same interface as for a regular matrix, I need to implement a slightly different subscript operator:

const double &LowerTriangular::operator()(unsigned i, unsigned j) const override {
    return data_[i*(i + 1)/2 + j];
}

The operator above is not complete though, since if someone asks for entries that are to the right of the diagonal (but still inside the theoretical matrix), another (unrelated) element is returned, but 0 should be returned instead.

Since references mustn't bind to local variables, I can't just return 0 . Thus, how can I achieve this?

I was only able to come up with making a local static variable:

const double &LowerTriangular::operator()(unsigned i, unsigned j) const override {
    static const double zero = 0;
    if (j > i) return zero;
    return data_[i*(i + 1)/2 + j];
}

I could make the function return by value, but what about the non-const version (when the caller actually needs to modify the contents)? How can I make sure that the caller doesn't modify the zero static variable? This works, but it's a bit ugly:

const double &LowerTriangular::operator()(unsigned i, unsigned j) const override {
    static double zero = 0;
    if (j > i) return zero = 0;  // kind of ugly but works
    return data_[i*(i + 1)/2 + j];
}

double &LowerTriangular::operator()(unsigned i, unsigned j) override {
    return const_cast<double &>( const_cast<const LowerTriangular &>(*this)(i, j) );
}

So what is the best solution?

Answer 1

Your chosen optimisation is in conflict with the interface that you provide.

One approach might be to not return a reference, but a transparent wrapper that behaves like a reference. Something similar to std::vector::<bool>::reference . An example:

struct Reference {
    double* element;

    operator double() const {
         return element
             ? *element
             : 0;
    }
    Reference& operator=(double d) {
        if (!element)
            throw std::out_of_range("Cannot modify right side of diagnoal");
        *element = d;
        return *this;
    }
};

const Reference
LowerTriangular::operator()(unsigned i, unsigned j) const {
    return {
        j > i
            ? nullptr
            : data_ + i*(i + 1)/2 + j
    };
}

Reference
LowerTriangular::operator()(unsigned i, unsigned j) {
    return {
        j > i
            ? nullptr
            : data_ + i*(i + 1)/2 + j
    };
}

This does have same caveats as std::vector::<bool>::reference , ie taking address of the reference doesn't give you pointer to the double object. This could be one of the few cases where overloading operator& makes sense. But that can be counter intuitive as well, when the user of the API is aware of the wrapper and does indeed want address of the wrapper.

Instead of throwing, you could specify that attempting to modify right side of diagonal is undefined behaviour.

Answer 2

When you return by constant reference:

Basic types (<= 8 or even 16 bytes) are usually returned by value in such cases (read only). Consider returning double instead of const double& .

When you return by non constant reference:

You can check the boundaries and throw an exception if accessing out of bounds or do as in many standard functions such as std::vector::operator[]: if accessing out of bounds, then this is undefined behaviour. Just document it so that the user of your function knows he must check himself.

Note that overloads can have different return types so you can return by value in the const case and by reference in the non const case.

You could also store a "zero" in a field of you class and return a reference to it if accessing in the null half of the matrix. You would have to set it to zero before returning the reference, just in case a malicious user changes it in the meantime.