Same function with const and without - When and why?

Question

T& f() { // some code ... } const T& f() const { // some code ... } 

I've seen this a couple of times now (in the introductory book I've been studying thus far). I know that the first const makes the return value const, in other words: unmodifiable. The second const allows that the function can be called for const declared variables as well, I believe.

But why would you have both functions in one and the same class definition? And how does the compiler distinguish between these? I believe that the second f() (with const) can be called for non-const variables as well.

Answer 1

But why would you have both functions in one and the same class definition?

Having both allows you to:

• call the function on a mutable object, and modify the result if you like; and
• call the function on a const object, and only look at the result.

With only the first, you couldn't call it on a const object. With only the second, you couldn't use it to modify the object it returns a reference to.

And how does the compiler distinguish between these?

It chooses the const overload when the function is called on a const object (or via a reference or pointer to const). It chooses the other overload otherwise.

I believe that the second f() (with const) can be called for non-const variables as well.

If that were the only overload, then it could. With both overloads, the non-const overload would be selected instead.

Answer 2

But why would you have both functions in one and the same class definition?

Sometimes you want to provide different semantics for same operation depending on whether it's being invoked on const object OR non-const object. Let's take an example of std::string class:-

char& operator[](int index); const char& operator[](int index) const; 

In this case when operator[] invoked through const object you won't let user to change the content of the string.

const std::string str("Hello"); str[1] = 'A';     // You don't want this for const. 

On the other hand,In case of non-const string you let user to change the content of string. That's why a different overload.

And how does the compiler distinguish between these?

Compiler checks whether that method is invoked on const object OR non-const object and then appropriately call that method.

const std::string str("Hello"); cout << str[1];           // Invokes `const` version.  std::string str("Hello"); cout << str[1];           // Invokes non-const version.