How to disambiguate overloaded template functions? - c++

Question

There is a problem with the following code. While 1 part is OK, the problem is with the 2nd part of the main(). On compilation, an ambiguous error message is displayed. How can I change the code to resolve the ambiguity?
template<typename Arg> void func(Arg arg)
{
arg();
}
template<typename Arg, typename... Args> void func(Arg arg, Args... args)
{
func(args...);
arg();
}
template<typename Container> void func(Container & c)
{
for (typename Container::reverse_iterator i = c.rbegin(); i != c.rend(); ++i )
{
(*i)();
}
}
void f()
{
std::cout << "+" ;
}
int main()
{
//1
func(f,f,f);
//2
std::vector<std::function<void()> > v{f,f};
func(v);
}
Link to code: http://cpp.sh/3wxrc

Answer 1

How can I change the code to resolve the ambiguity?
Maybe using template-template ?
template <template <typename ...> class Cont, typename ... Ts>
void func (Cont<Ts...> & c)
{
for (typename Cont<Ts...>::reverse_iterator i = c.rbegin(); i != c.rend(); ++i )
{
(*i)();
}
}
Deleting the func() Container based version, obviously.
Simply defining a template parameter Container, doen't make it different from a generic Arg template parameter.
I know that you use typename Cont<Ts...>::reverse_iterator inside the function. But the compiler has to choose the right overloading according the function signature, not according the body of the functions.
Using a Cont<Ts...> parameter, you have something more specialized.

Answer 2

If you have C++17 there is std::enable_if_t which can be used with std::is_invocable_v (this requiries C++17) :
template<typename Arg>
std::enable_if_t<std::is_invocable_v<Arg>>
func(Arg arg)
{
arg();
}
https://wandbox.org/permlink/E2PoQdMv1pwXdMgO

Answer 3

I would first split (variadic) iteration, from singular job:
// func overloads with one parameter.
template <typename ...Ts>
void funcs(Ts&&... args)
{
const int dummy[] = {(func(std::forward<Ts>(args)), 0)..., 0};
static_cast<void>(dummy); // Avoid warning for unused variable
// Or in C++17:
// (func(std::forward<Ts>(args)), ...);
}
Then for your methods with only one argument, there are ambiguous for any lvalue reference, as signatures are:
template<typename Arg> void func(Arg arg);
template<typename Container> void func(Container & c);
You might use SFINAE to differentiate them:
template<typename Arg>
auto func(Arg arg)
-> decltype(arg(), void())
{
arg();
}
template<typename Container>
auto func(Container& c)
-> decltype(c.rbegin() != c.rend(), (*c.rbegin())(), void())
{
for (auto it = c.rbegin(); it != c.rend(); ++it)
{
(*it)();
}
}
Demo

Answer 4

The problem is that it couldn't deduce which func to call` the first one or the third. This is how you can make it work without changing your hierarchy of function overloadings or do as it answered in last comment
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
template<typename Arg>
void func(Arg* arg)
{
arg();
}
template<typename Arg, typename... Args>
void func(Arg arg, Args... args)
{
func(args...);
arg();
}
template<typename Container>
void func(Container&& c)
{
for (typename Container::reverse_iterator i = c.rbegin(); i != c.rend(); ++i )
{
(*i)();
}
//OR Which is bettere to use
/*for(auto && e : c){
e();
}*/
}
void f()
{
std::cout << "+" ;
}
int main()
{
//1
func(f,f,f);
//2
std::vector<std::function<void()> > v{f,f};
func(std::move(v));
}