Question

Following is the test code:

struct A
{
  operator int ();
  operator int () const;
};

void foo (const int);

Now, upon invoking:

foo(A());  // calls A::operator int()

Why does it always chooses the non-const version ? Even making operator const int () const; doesn’t have any effect on invoking foo(). Apart from standard reference, can someone explain logically, the reason behind it ?

Answer 1

A() gives you a temporary A object that is not const-qualified. The A() expression is an rvalue expression, yes, but that does not make the A object const-qualified.

Since the A object is not const-qualified, the non-const operator int() is an exact match and the const operator int() requires a qualification conversion, so the non-const overload is selected as the best match.

If you want it to be const-qualified, you’d need to explicitly request a const-qualified A:

foo(identity<const A>::type());

where identity is defined as

template <typename T>
struct identity { typedef T type; };

Note that there is really no difference between operator const int() const and operator int() const: the result is an rvalue and only class-type rvalues can be const-qualified (int is not a class type).

Note also that there is no difference between the void foo(const int) that you have and void foo(int). Top-level const-qualifiers on parameter types do not affect the type of the function (i.e., the type of both of those declarations is void foo(int)). Among other reasons, this is because it doesn’t matter to the caller whether there is a top-level const-qualifier; it has to make a copy regardless. The top-level const-qualifier affects only the definition of the function.