error: reference to overloaded function could not be resolved - c++

Question

The following code:
struct A
{
using this_t = A;
template <class F1>
void ins(const F1& fu)
{
}
template <class F1, class... Args>
void ins(const F1& fu, const Args&... args)
{
this_t::ins<Args...>(args...);
// the line which is causing the error:
constexpr decltype(&this_t::ins<Args...>) func = &this_t::ins<Args...>;
}
};
int main()
{
A a;
a.ins(5, 5, 5, 5, 5);
}
Gives this error:
error: reference to overloaded function could not be resolved
As shown here: https://godbolt.org/z/nJiY4A
What's going wrong here and how is it possible to get the pointer to the function then?

Answer 1

I think I know why that line fails to compile. It has little to do with overload resolution, and everything to do with decltype:
[over.over]/1 A use of an overloaded function name without arguments is resolved in certain contexts to a function, a pointer to function or a pointer to member function for a specific function from the overload set. A function template name is considered to name a set of overloaded functions in such contexts. A function with type F is selected for the function type FT of the target type required in the context if F (after possibly applying the function pointer conversion (7.13)) is identical to FT. The target can be
(1.1) — an object or reference being initialized (11.6, 11.6.3, 11.6.4),
(1.2) — the left side of an assignment (8.18),
(1.3) — a parameter of a function (8.2.2),
(1.4) — a parameter of a user-defined operator (16.5),
(1.5) — the return value of a function, operator function, or conversion (9.6.3),
(1.6) — an explicit type conversion (8.2.3, 8.2.9, 8.4), or
(1.7) — a non-type template-parameter (17.3.2).
The overloaded function name can be preceded by the & operator. An overloaded function name shall not be used without arguments in contexts other than those listed.
Emphasis mine. Just mentioning an overloaded function name outside of those enumerated contexts - e.g. in decltype(&this_t::ins<F2, Args...>) - renders the program ill-formed. Avoiding this problematic usage by spelling the type explicitly makes the code compile:
void (this_t::*func)(const Args&...) = &this_t::ins<Args...>;

Answer 2

I'm not yet sure why taking an address of the overloaded function behaves differently than calling it; why the former produces an ambiguity while the latter is able to resolve the overload successfully.
Meanwhile, here's one possible workaround:
struct A
{
using this_t = A;
template <class F1>
void ins(const F1& fu)
{
}
template <class F1, class F2, class... Args>
void ins(const F1& f1, const F2& f2, const Args&... args)
{
this_t::ins<F2, Args...>(f2, args...);
// the line which is causing the error:
constexpr decltype(&this_t::ins<F2, Args...>) func = &this_t::ins<F2, Args...>;
}
};
The tweak is to make the first overload callable with one argument, and the second with two or more. Demo

Answer 3

Not exactly what you asked but... if you can use an empty (do nothing, nothing receiving) ground recursion case, I propose the following solution
struct A
{
using this_t = A;
template <int = 0>
void ins ()
{ }
template <typename F1, typename ... Args>
void ins (F1 const &, Args const & ... args)
{
this_t::ins<Args...>(args...);
// no more error
constexpr decltype(&this_t::ins<Args...>) func = &this_t::ins<Args...>;
}
};
This way, calling ins<Args...>, you can avoid all ambiguities when Args... is only one type (only the recursion case matches) and when Args... is empty, matches the ground case thanks to the int = 0 template default value.