C++ overload operator twice, one return non-const reference and the other const reference, what is the preference?

Question

I overload an operator twice with the same parameter list. but with different return type:

T& operator()(par_list){blablabla}    
const T& operator()(par         


        

Answer 1

The way you define your operators, no way the compiler can decide which operator() to call. Overloading of functions (and operators) can only be done on the type of the arguments, never on the return type. And in fact, you will have an error at compilation as soon as you define the second one, the compiler considering that you are redefining the same function/operator.

However, the following is common (and probably what you have):

T& operator()(par_list){blablabla}
const T& operator()(par_list) const {blablabla}

This additional "const" after the argument list exists because you are defining non-static member functions and member functions have an implicit hidden argument: the "this" pointer to the instance of the class. The "const" keyword there indicates if this hidden pointer is to a const instance or not. This argument participates to the overloading resolution and that is in this case what the compiler use to choose which version of the operator to use.

So:

class A {
    T& operator()() { ... }
    const T& operator()() const { .... }
};

A a;
const A& ca(a);
a(); -> returns a T&
ca(); -> returns a const T&