Implicit conversion when overloading operators for template classes

Question

I would like to know why implicit type conversion doesn\'t work with outside operator overloading on class templates. Here is the working, non-templated version:

<         


        

Answer 1

I put this question to the library authors at MS and got an extremely informative response from Stephan Lavavej, so I give him full credit for this information.

The compile error you get in the template case is due to the fact that template argument deduction runs before overload resolution, and template argument deduction needs exact matches to add anything to the overload set.

In detail, template argument deduction looks at each pair of parameter type P and argument type A, and tries to find template substitutions that will make A exactly match P. After finding matches for each argument, it checks for consistency (so that if you call bar(foo, foo) with T=int for the first parameter and T=double as the second, it also fails). Only after exact, consistent matches are successfully substituted in the function signature is that signature added to the set of candidate functions for overload resolution.

Only after all ordinary functions (found through name lookup) and matching function template signatures have been added to the overload set is overload resolution run, at which point all of these function signatures are evaluated for a "best match", during which time implicit conversions will be considered.

For the operator+(foo, foo) case with foo + 5, template argument deduction can find no substitution for T that will make the expression foo exactly match int, so that overload of operator+ gets tossed out as a candidate and the implicit conversion is never even seen.

The opinion here seems to be that this is generally a good thing, as it makes templates much more predictable, leaving the realm of strange implicit behaviors to overload resolution.

The standard has plenty to say about this at:

14.8.2.1 Deducing template arguments from a function call

"Template argument deduction is done by comparing each function template parameter type (call it P) with the type of the corresponding argument of the call (call it A) as described below. ...

... In general, the deduction process attempts to find template argument values that will make the deduced A identical to A (after the type A is transformed as described above)"

It goes on to list a few special cases where this rule has exceptions involving cv-qualifiers (so T& will be compatible with const T&), and matching of derived classes (it can in some cases match Derived& to Base&) but basically, exact matching is the rule.