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 function part of a class, takes an index and checks that its logical, 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 version?
This sample question also might help elaborate.
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.
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.
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
