unresolved overloaded function

in C++11, let's say I have some code like this:

Code:

template<typename Func>
auto Wrapper(Func func) -> decltype(func())
{
    return func();
}

template<typename Func, typename... Args>
auto Wrapper(Func func, Args... args) -> decltype(func(args...))
{
    return func(args...);
}

void foo(int x, std::string y)
{

}

int foo()
{
    return 3;
}

void bar()
{
    Wrapper(foo, 3, "foo");
    int x = Wrapper(foo);
}

if I change the name of one of the foo() functions, it compiles without error, but if both functions are named foo, the compiler gives me the following errors:

Code:

In function 'void bar()':
error: no matching function for call to 'Wrapper(<unresolved overloaded function type>, int, const char [4])'
note: candidates are:
note: template<class Func> decltype (func()) Wrapper(Func)
note: template<class Func, class ... Args> decltype (func(Wrapper::args ...)) Wrapper(Func, Args ...)
error: no matching function for call to 'Wrapper(<unresolved overloaded function type>)'
note: candidates are:
note: template<class Func> decltype (func()) Wrapper(Func)
note: template<class Func, class ... Args> decltype (func(Wrapper::args ...)) Wrapper(Func, Args ...)

is there a way to use overloaded functions with this wrapper? if so, how do I need to qualify the function names so that the compiler knows I want the one with two parameters or the one with no parameters?

You can tell the compiler the type of the function pointer corresponding to the foo you wish to pass along:

Code:

void bar()
{
    Wrapper<void (*)(int, std::string)>(&foo, 3, "foo");
    int x = Wrapper<int (*)()>(&foo);
}

This works for me in VS2012.

The problem is essentially with how template deduction works. The compiler will try to match the type of what you pass in to the template parameters, but never goes further.
Since foo has two different signatures and the only way to tell them apart is the return type, you are going to get a compile error.

Also note that if you're getting into this situation due to things from different places having the same name, that you can simply wrap one or the other inside a namespace. In fact I've seen a namespace declaration directly around a #include to prevent this problem when it came from third-party code.

The non-variadic Wrapper function, by the way, is not necessary. The variadic version can instantiate to the same thing simply by using an empty parameter pack.
Also, may I suggest (assuming that you didn't just simplify that part away in your reduced example) that you use perfect forwarding syntax for the wrapper?

Code:

template<typename Func, typename... Args>
auto Wrapper(Func func, Args&&... args) -> decltype(func(std::forward<Args>(args)...))
{
    return func(std::forward<Args>(args)...);
}

I honestly didn't even know that it could be done that way. I'll keep that in mind in the future.