Why this constant struct can be modified in this way?

Question

Recently I encounter the following code, it is an excerpt from tutorial of open-source package AMReX text

Array4<Real> const& a = fab1.array();
    Dim3 lo = lbound(a);
    Dim3 hi = ubound(a);
    int nc = a.nComp();
    for(int n=0; n<nc; n++){
        for(int i=lo.x; i<=hi.x; i++){
            for(int j=lo.y; j<=hi.y; j++){
                for(int k=lo.z; k<=hi.z; k++){
                    a(i, j, k, n) = 2.0;
                }
            }
        }
    }

Array4 is a class with template which stores the data of grid points, like matrix, tensor etc. I am wondering why here variable "a" as a reference referring to a constant object can be used to modify the object's data. What are the reasons behind it? Thanks!

The tutorial says that "const means the Array4 object itself cannot be modified to point to other data". So why Array4 object can be modified here?

Answer 1

why Array4 object can be modified here?

Because the overloaded Array4::operator() returns a non-const lvalue ref which can be used to modify the referred to object from outside(by the caller).

template <class U=T, std::enable_if_t<!std::is_void_v<U>,int> = 0>
//see the RETURN TYPE IS NON-CONST LVALUE REF        
U& operator() (int i, int j, int k) const noexcept {
 //other code here
}

Answer 2

class DateTest{
    public:
        int* dateArray;
        DateTest(){
            dateArray = (int*) malloc(sizeof(int)*3);
            dateArray[0] = 1000;
            dateArray[1] = 12;
            dateArray[2] = 13;
        }
        int& getYear() const{
            return dateArray[0];
        }
};

    DateTest const& date = DateTest();
    int& tmp = date.getYear();
    tmp = 5;
    cout << date.getYear() << endl;

I wrote a simple test to show the reason behind it.
It is due to the fact that a constant reference calls a constant function, but the function does return a non-constant reference.
That's why we could modify the variables.