C++ - overloading [] operator

问题

I have a template class Array:

template <class T=int, int SIZE=10>
class Array {
    T TheArray[SIZE];
public:
    void Initialize() {
        for (int idx=0; idx < SIZE; idx++) {
            TheArray[idx] = T();
        }
    }

    T& operator [](int idx) {
        return TheArray[idx];
    }

    T operator [](int idx) const {
        return TheArray[idx];
    }
}

I have some questions on operator [] overloading (I found this example on net).

I understand that T& operator [](int idx) returns a reference to an array value with index idx and that T operator [](int idx) const returns its value. However, I am not sure in which case a reference or a value will be returned by using the [] operator.

Also, if I change T operator [](int idx) const -> T operator [](int idx), the compiler complains. Why is that? I can understand that the compiler complains because only the return type is different, but why doesn't it complain when const is added? This only means that none of the class internals are modified, right?

I tried to debug this small main implementation:

int main() {
    int val;
    Array<> intArray;

    intArray.Initialize();
    val = intArray[1];
    printf("%d", intArray[1]);
    intArray[1] = 5;
}

And each time T& operator [](int idx) is called. Why?

Thanks in advance.

回答1:

The operator[] overload will be selected based on the const-qualification of the object you call it on.

Array<> intArray;
intArray[1]; //calls T& operator[]

const Array<> constArray;
constArray[1]; //calls T operator[]

If you remove the const from T operator[], you get an error because the member functions cannot have the same const-qualification and parameters as there would be no way to select between them.

回答2:

First thing, regard [] as syntactic sugar for calling this->operator[].

The const version will be called if this is a const pointer, else the non-const version will be called.

Moving on, you ought to use const T& operator [](int idx) const {, i.e. have the const version return a const reference. That will save the overhead of taking a deep copy.

Finally, the const-ness of a function is part of its signature. This allows you to overload based on const-ness. Otherwise you couldn't have the two versions of operator[].

来源：https://stackoverflow.com/questions/34593263/c-overloading-operator