Const and Non-Const Operator Overloading

I have a topic I'm confused on that I need some elaborating on. It's operator overloading with a const version and a non-const version.

// non-const
double &operator[](int idx) {
    if (idx < length && idx >= 0) {
        return data[idx];
    }
    throw BoundsError();
}

I understand that this lambda function, takes an index and checks its validity and then returns the index of the array data in the class. There's also a function with the same body but with the function call as

const double &operator[](int idx) const

Why do we need two versions?

For example, on the sample code below, which version is used in each instance below?

Array a(3);
a[0] = 2.0;
a[1] = 3.3;
a[2] = a[0] + a[1];

My hypothesis that the const version is only called on a[2] because we don't want to risk modifying a[0] or a[1].

Thanks for any help.

Solution 1:

When both versions are available, the logic is pretty straightforward: const version is called for const objects, non-const version is called for non-const objects. That's all.

In your code sample a is a non-const object, meaning that the non-const version is called in all cases. The const version is never called in your sample.

The point of having two versions is to implement "read/write" access for non-const objects and only "read" access for const objects. For const objects const version of operator [] is called, which returns a const double & reference. You can read data through that const reference, but your can't write through it.

Solution 2:

To supply a code example to complement the answer above:

Array a(3);
a[0] = 2.0;  //non-const version called on non-const 'a' object

const Array b(3);
double var = b[1];  //const version called on const 'b' object

const Array c(3);
c[0] = 2.0;  //compile error, cannot modify const object