Question

I have a struct with these operators (given some type T):

T& operator[](size_t i) { return write(i); }
const T& operator[](size_t i) const { return get(i); }

When I access a non-const object of this by [i], will it always use the non-const operator[] or will it automatically see which one is needed (e.g. if the const-version is “enough”) and take that one? What are the rules there? And do most compilers (I mostly care about Clang, recent GCC and recent MSVC) behave the same there?

Background: write(i) could be much more costly than get(i). I even have some code where the behavior is slightly different, where write(i) might touch some files, set some modified-flags or whatever.

Answer 1

As with any member function, the choice of overload depends on the type of the implicit instance argument:

T x;

x.foo();                        // #1
const_cast<T const &>(x).foo(); // #2

In case #1, the implicit instance argument has type T, so the overload T::foo() is viable and will be selected. In case #2, the implicit instance argument has type T const, and thus only an overload T::foo() const is viable, and will be selected if it exists.

The normal overload resolution rules are at play here: If you have both const and non-const overloads and the instance argument is non-constant, then the non-constant version is chosen because it requires zero conversions, while the const overload would require one (standard) conversion, namely from T & to T const &, and thus that overload is not as good a fit as the non-const one.