C ++相同的方法签名但返回类型不同

Question

I have seen the following code:

template <class T>
class Type {
    public:
        Type() {}
        T& operator=(const T& rhs) {value() = rhs; return value();}
        T& value() {return m_value;}
        T value() const {return m_value;}
    private:
        T m_value;
};

Why does the compiler not complain about

    T& value() {return m_value;}
    T value() const {return m_value;}

and how to know which one is invoked?

Answer 1

The two functions are actually not the same. Only the second function is declared as a const member function. If the object that the member is called from is const , the latter option is used. If the object is non- const , the first option is used.

Example:

void any_func(const Type *t)
{
    something = t->value(); //second `const` version used
}

void any_func2(Type *t)
{
    something = t->value(); //first non-`const` version used
}

If both functions were declared non- const or both were declared const , the compiler would (should, anyway) complain.

Answer 2

Why does the compiler not complain about

Because the const counts for a different function signature. Your assumption the function signatures are identical is wrong.
The function marked as const will be invoked for any const instance or reference of Type<T> .

and how to know which one is invoked?

Put a cout statement in the functions and test the following cases:

template <class T>
class Type {
    public:
        Type() {}
        T& operator=(const T& rhs) {value() = rhs; return value();}
        T& value() { 
            std::cout << "non const version" << std endl;
            return m_value;
        }
        T value() const { 
            std::cout << "const version" << std endl;
            return m_value;
        }
    private:
        T m_value;
};

---

int main() {
    Type<int> t;
    t.value();

    Type<int> rt = t;
    rt.value();

    Type<int>* pt = &t;
    pt->value();

    const Type<int> ct;
    ct.value();

    const Type<int>& crt = t;
    crt.value();

    const Type<int>* pct = &t;
    pct->value();
}

Your assignment operator will call the non const version.

---

The const version should better look like

const T& value() const { 
     std::cout << "const version" << std endl;
     return m_value;
}

because you can't always rely on RVO (return value optimization), and extra copies might be taken (especially for older compiler implementations).

---

Also note the assignment operator should return a reference to the current instance:

 Type& operator=(const T& rhs) {value() = rhs; return *this;}

Answer 3

A couple of words on functions resolution priority. Compiler distinguishes between const/non const functions on following way:

If a class has only const function with given name and argument list, it will be called for constant and non-constant objects alike. After calling this function, object will 'assume' constness (even if it was not const), meaning that the function can only call other const functions.

If a class has only non-const function, it will be called for non-const objects. Attempt to call this function for const objects will lead to compilation error.

If a class has both functions available, const version will be used for const objects, non-const version will be used for non-const objects.

Thanks to @owacoder for pointing my attention to initial mixup in the description.