Re: Overload resolution with template and non-template functions
On Jul 20, 1:20 pm, Rodolfo Lima <rodl...@gmail.com> wrote:
Hi, the snippet bellow compiles with Visual Studio and doesn't compile
with gcc-4.2. After some debating over gcc mailing list, we've nailed
it to a possible misinterpretation of the standard, section 13.4,
paragraph 1.
template <class T> void foo() {}
void foo() {}
template <class F> void bar(F f) {}
bar(&foo);
Visual Studio compiles fine, and the overload used is the non template
function. But gcc chokes at the "bar" call, saying:
"error: no matching function for call to 'bar(<unresolved overloaded
function type>)'"
According to the standard, an overload resolution attempt should be
done if and only if it's one of the 7 cases outlined there. One of the
cases is when the target of the address expression is a function's
argument (case 3).
No, case 3 states that the target must a function parameter type - not
a function argument type. And in order for bar() to have a function
parameter whose type could be matched - bar() must first be
instantiated (or "specialized"). Now, instantiating bar() in this
particular case, first requires deducing "&foo"'s type. And since
deducing a template type parameter from the address of an overloaded
function name does not lead to overload resolution (in other words, it
is not one of the seven cases listed in '13.4), the use of "&foo" in
this context is ill-formed. So gcc is correct.
Note that explicitly specializing bar() would provide a function
parameter type that can be matched with "&foo". For example:
template <class T> void foo() {}
void foo() {}
template <class F> void bar(F f) {}
int main()
{
bar<void(*)()>(&foo); // OK
}
Explicitly specializing the function template bar() means that the
call to bar() now has a function parameter type to serve as a target
for "&foo". So in this case, overload resolution does take place - it
succeeds - and the program is well-formed.
Visual Studio seems to match the call above to case 3, but GCC
doesn't, maybe because the call target is a template function's
argument, not a "function's argument". Now... by saying "a parameter
of a function (5.2.2)", the case 3 includes both template and non
template functions, or just the latter?
Case 3 applies to functions and function template specializations.
Case 3 does not apply to template type deduction - and since none of
the other six cases do either - the original program is ill-formed.
Greg
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]