Taking the address of an overloaded function template is possible, sometimes

Question

On gcc 4.9.0:

#include <iostream>
#include <map>

struct A
{
    typedef int type;
};

template<typename T> void foo(T*) { std::cout << "a" << std::endl; }
template<typename T> void foo(typename T::type*) { std::cout << "b" << std::endl; }

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

template<typename T> void bar(T*) { std::cout << "a" << std::endl; }
template<typename T> void bar(typename identity<T>::type*) { std::cout << "b" << std::endl; }

int main()
{
    //auto f = foo<A>; // ambiguous
    foo<A>(0); // prints "b", as the second overload is more specific

    auto b = bar<A>; // fine
    bar<A>(0); // prints "b", as the second overload is more specific (?)
    b(0); // prints "b"

    return 0;
}

Any clue on why the address can be taken, in the second case?

@T.C., g++ 4.9.2 compiles the code and produces output that matches OP's description. — R Sahu, Jul 13 '15 at 19:49
[Demo with clang 3.6.0 (reject) && gcc 5.1.0 (accept)](http://coliru.stacked-crooked.com/a/56db4f441db80196) — Jarod42, Jul 13 '15 at 19:53
@T.C. Clang is wrong here I think. At least in rejecting `bar`, it's correct in rejecting `foo` — Barry, Jul 13 '15 at 19:55

Barry · Answer 1 · 2015-07-13T22:05:28.427

3

The deduction for auto is the same as template deduction. From [dcl.spec.auto]:

When a variable declared using a placeholder type is initialized, [...], the deduced return type or variable type is determined from the type of its initializer. If the placeholder is the auto type-specifier, the deduced type is determined using the rules for template argument deduction. If the placeholder is the auto type-specifier, the deduced type is determined using the rules for template argument deduction.

So when we have either:

auto f = foo<A>;
auto b = bar<A>;

We are performing type deduction as if we called (to borrow T.C.'s choice of words):

template <typename M> void meow(M );
meow(foo<A> );
meow(bar<A> );

and using the deduced type M as the type of f and b, respectively.

But, according to [temp.deduct.type], emphasis mine:

If a template parameter is used only in non-deduced contexts and is not explicitly specified, template argument deduction fails.

The non-deduced contexts are:
— [...]
— A function parameter for which argument deduction cannot be done because the associated function argument is a function, or a set of overloaded functions (13.4), and one or more of the following apply:
    — more than one function matches the function parameter type (resulting in an ambiguous deduction), or
    — no function matches the function parameter type, or
    — the set of functions supplied as an argument contains one or more function templates.
— [...]

In both cases, the argument is a set of overloaded functions which contains one or more function templates - which makes it a non-deduced context, so template argument deduction fails. Thus, clang is correct in rejecting both initializations.

edited Jul 13 '15 at 22:05

answered Jul 13 '15 at 19:55

Barry

286,269
29
621
977

This is tricky. I'm inclined to think that [temp.deduct.type]/5.5.1 makes it a non-deduced context, meaning that `auto`'s deduction should fail in both cases. – T.C. Jul 13 '15 at 19:59
@gd1 For a more thorough answer on partial ordering, check out [Columbo's answer here](http://stackoverflow.com/a/31051322/2069064) – Barry Jul 13 '15 at 20:05
@Barry I'm not talking about the deduction for `bar` (there's obviously no deduction there), I'm talking about the deduction for `auto`, which is as if you did `template void meow(M); meow(bar);` and deduce `M`. – T.C. Jul 13 '15 at 20:05
@Barry Remember that template argument deduction happens before overload resolution. So first you need to deduce `M`, and then use the rules in [over.over] to pick an overload. But `M` can't be deduced here because you have an overloaded function set. – T.C. Jul 13 '15 at 20:13
@T.C. There we go. I believe that's now the correct answer? – Barry Jul 13 '15 at 21:28
I don't think it's the "function templates" subbullet (that's for a *template-name* like `foo`, I think, rather than a *template-id* like `foo`, the latter names a set of function template specializations, not function templates). Rather, the first subbullet applies - deduction succeeds for two members of the overload set -> non-deduced context. – T.C. Jul 13 '15 at 21:31
@T.C. Yeah I think you're right. First one fits too, either way. – Barry Jul 13 '15 at 21:33

Taking the address of an overloaded function template is possible, sometimes

1 Answers1