In c++, why does the compiler choose the non-const function when the const would work also? [duplicate]

Answer 1

The compiler does not take into account how you are using the return value in its determination; that's not part of the rules. It doesn't know if you're doing

std::string name = b->Name();

or

b->Name() = "me";

It has to choose the version that works in both cases.

Answer 2

Two answers spring to mind:

1. The non-const version is a closer match.

2. If it called the const overload for the non-const case, then under what circumstances would it ever call the non-const overload?

You can get it to use the other overload by casting a to a const Foo *.

Edit: From C++ Annotations

Earlier, in section 2.5.11 the concept of function overloading was introduced. There it noted that member functions may be overloaded merely by their const attribute. In those cases, the compiler will use the member function matching most closely the const-qualification of the object:

Answer 3

You can add a "cName" function that is equivalent to "Name() const". This way you can call the const version of the function without casting to a const object first.

This is mostly useful with the new keyword auto in C++0x, which is why they are updating the library to include cbegin(), cend(), crbegin(), crend() to return const_iterator's even if the object is non-const.

What you are doing is probably better done by having a setName() function that allows you to change the name rather than returning a reference to the underlying container and then "maybe" it is modified.

Answer 4

Because a is not a const pointer. Therefore, a non-const function is a closer match. Here is how you can call the const function:

const Foo* b = a;
std::string name = b->Name();

If you have both a const and a non-const overload, and want to call the const one on a non-const object, this might be an indication of bad design.