Question

If I compile (gcc 4.6.0) and run this code:

#include <iostream>

template <typename T> void F(/* const */ T& value) {
    std::cout << "T & " << value << std::endl;
}

template <typename T> void F(/* const */ T* value) {
    std::cout << "T * " << value << std::endl;
    F(*value);
}

int main(int argc, char* argv[]) {
    float f = 123.456;   
    float* pf = &f;

    F(pf);

    return 0;
}

I get the following output:

T * 0x7fff7b2652c4
T & 123.456

If I uncomment the const keywords I get the following output:

T & 0x7fff3162c68c

I can change float* pf = &f; to const float* pf = &f; to get the original output again, that’s not the issue.

What I’d like to understand is why, when compiling with the const modifiers, overload resolution considers const T& value a better match than const T* valuefor a non-const float*?

Answer 1

During overload resolution, overloads requiring no conversions beat overloads requiring some conversions, even if those conversions are trivial. Quoting the C++03 standard, [over.match.best] (§13.3.3/1):

Define ICSi(F) as follows:

• if F is a static member function, ICS1(F) is defined such that ICS1(F) is neither better nor worse than ICS1(G) for any function G, and, symmetrically, ICS1(G) is neither better nor worse than ICS1(F); otherwise,
• let ICSi(F) denote the implicit conversion sequence that converts the i-th argument in the list to the type of the i-th parameter of viable function F. 13.3.3.1 defines the implicit conversion sequences and 13.3.3.2 defines what it means for one implicit conversion sequence to be a better conversion sequence or worse conversion sequence than another.

Given these definitions, a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then

• for some argument j, ICSj(F1) is a better conversion sequence than ICSj(F2), or, if not that,
• F1 is a non-template function and F2 is a function template specialization, or, if not that,
• F1 and F2 are function template specializations, and the function template for F1 is more specialized than the template for F2 according to the partial ordering rules described in 14.5.5.2, or, if not that,
• the context is an initialization by user-defined conversion (see 8.5, 13.3.1.5, and 13.3.1.6) and the standard conversion sequence from the return type of F1 to the destination type (i.e., the type of the entity being initialized) is a better conversion sequence than the standard conversion sequence from the return type of F2 to the destination type.

When const is present, in order to call the overload taking a reference, no conversion is necessary — T is deduced to be float* and the argument is float* const&. However, in order to call the overload taking a pointer, float would need to be converted to float const for said overload to be viable. Consequently, the overload taking a reference wins.

Note, of course, that if pf were changed to be a float const*, the behavior would go back to the way you expected because the overload taking a pointer would no longer require a conversion.