How to overload the "[][] operator" in a constant array?

Question

been stuck at this for a while. I have a mathlibrary with a 3x3 matrix class. It used to be dynamic , using a pointer and allocating memory of creation. But as its always gonna be 3x3 I decided to change it, but now I cant use [][] to get values of my array. I am using a proxy class!

class mat3 {
    private:
        double arr[3][3];

    public:
        mat3();
        mat3(double, double, double, double, double,
            double, double, double, double);

                    //Proxy class
        class Proxy {
            private:
                double arr[3];
            public:
                Proxy(const double _arr[3]) { arr = _arr; }
                double& operator[] (const int index) {
                    return arr[index];
                }
                const double& operator[] (const int index) const{
                    return arr[index];
                }
        };

        const Proxy operator[] (const int index) const{
            return Proxy(arr[index]);
        }

        Proxy operator[] (const int index) {
            return Proxy(arr[index]);
        }

Now where arr = _arr i get a compiler error: Error: Expression must be a modifiable Ivalue

What am I doing wrong? How am I suposed to achieve this?

Answer 1

When you pass an array as a parameter, it gets converted to a pointer, so your constructor is the same as Proxy(const double *_arr) { arr = _arr; } and that's illegal.

Besides, you want to return a reference to the original values in mat3. So change Proxy to use a pointer to double instead:

class Proxy {
private:
   double *arr;
...
};

Answer 2

You don't need Proxy class, you may just do:

class mat3
{
    using row_type = double [3];
public:
    mat3();
    mat3(double, double, double, double, double, double, double, double, double);

    const row_type& operator[](const int index) const { return arr[index]; }
    row_type& operator[](const int index) { return arr[index]; }

private:
    row_type arr[3]; // or double arr[3][3];
};

Note also that using std::array<std::array<double, 3>, 3> arr; would be more intuitive to edit code that C-array.

If really you want to have your Proxy class, you may use:

class mat3
{
    using row_type = double[3];

public:
    mat3();
    mat3(double, double, double, double, double, double, double, double, double);

    class Proxy
    {
    private:
        row_type& arr; // or double (&arr)[3];

    public:
        explicit Proxy(row_type& arr) : arr(arr) {}
        double& operator[](const int index) { return arr[index]; }
        const double& operator[](const int index) const { return arr[index]; }
    };

    const row_type& operator[](const int index) const { return arr[index]; }

    row_type& operator[](const int index) { return arr[index]; }

private:
    row_type arr[3]; // or double arr[3][3];
};

Answer 3

Surprisingly this works (I wasn't expecting it to):

#include <iostream>

struct matrix
{
    typedef double ((&reference)[3])[3]; // define a reference type to a 3x3 array

    double array[3][3];

    operator reference() // implicit conversion to 3x3 array reference
    {
        return array;
    }

    void dump()
    {
        for(unsigned x = 0; x < 3; ++x)
            for(unsigned y = 0; y < 3; ++y)
                std::cout << array[x][y] << '\n';
    }
};

int main()
{
    matrix m;

    for(unsigned x = 0; x < 3; ++x)
        for(unsigned y = 0; y < 3; ++y)
            m[x][y] = x * y; // seems to work okay!!!

    m.dump();
}