Question

I have this code that relies on SFINAE and default template arguments. It works as expected, except for the last two commented lines:

#include <tuple>
#include <iostream>
using namespace std;

template<typename T> void push(T val){
    cout<<val<<endl;
}

template<typename T> T to(){
    T dummy;
    cin>>dummy;
    return dummy;
}

template<typename T, T> class function_proxy{
    static_assert(sizeof(T)!=sizeof(T), "Error: function_proxy works with functions (duh)");
};

template<typename Return, typename... Args, Return(*func)(Args...)> class function_proxy<Return(*)(Args...), func>{
    static Return call(Args... args){
        return func(args...);
    }
    template<typename... retrieved> static Return call(retrieved... read){
        return call(read..., to<typename tuple_element<sizeof...(read), tuple<Args...> >::type >());
    }
public:
    template<typename Ret=Return, typename enable_if<!is_void<Ret>::value, int>::type=0>
    static int wrapper(){
        push(call());
        return 1;
    }

    template<typename Ret=Return, typename enable_if<is_void<Ret>::value, int>::type=0>
    static int wrapper(){
        call();
        return 0;
    }
};

int f(int arg){ return arg*3; }
void g(){ cout<<"g does nothing"<<endl; }

int main(){
    //SFINAE works nicely
    function_proxy<decltype(&f), &f>::wrapper();
    function_proxy<decltype(&g), &g>::wrapper();
    //Here it doesn't, even though there should be no ambiguity:
    //function_proxy<decltype(&f), &f>::wrapper;
    //function_proxy<decltype(&g), &g>::wrapper;
}

You can see that when I call the template function, SFINAE does its job. But when I try to take the address of the only function that wouldn’t be ill-formed, g++ complains that it cannot resolve the address of the overloaded function.

Is there a way to solve this problem without explicitly telling the first template parameter of these overloaded function? In theory, it’s redundant. Also, my code that use this helper class is heavily generic and so the return type of what here are f and g might not be so trivial to fetch.

Answer 1

SFINAE applies only during overload resolution, and if there is no function call, there is no overload resolution.