Class member function to std::function

#include <functional>
#include <iostream>
 
template <typename C, typename R, typename... Args>
R wrapper_raw(const C& thisref, R (C::*func)(Args...) const, Args... args)
{
    std::cout << "CALLING: ";
    return (thisref.*func)(args...);
}
 
template <typename C, typename F, typename... Args>
typename F::result_type wrapper_funcobj(const C& thisref, F func, Args... args)
{
    std::cout << "CALLING: ";
    return func(thisref, args...);
}
 
template <typename R, typename C, typename... Args>
R wrapper_stdfunc(const C& thisref, std::function<R (const C&, Args...)> func, Args... args)
{
    std::cout << "CALLING: ";
    return func(thisref, args...);
}
 
template<typename R, typename C, typename ...Args>
std::function<R (const C&, Args...)> make_stdfun(R (C::*func)(Args...) const)
{
    return func;
}
 
struct Foo
{
    Foo(int num = 0) : num_(num) { }
    void print_add(int i) const { std::cout << num_ + i << '\n'; }
 
    void wtf()
    {
        wrapper_raw(*this, &Foo::print_add, 1);                                             // works
        wrapper_funcobj(*this, std::mem_fn(&Foo::print_add), 2);                            // works
        wrapper_funcobj(*this, std::function<void(const Foo&, int)>(&Foo::print_add), 3);   // works
        wrapper_funcobj(*this, make_stdfun(&Foo::print_add), 4);                            // works
        wrapper_stdfunc(*this, make_stdfun(&Foo::print_add), 5);                            // works
        wrapper_stdfunc(*this, &Foo::print_add, 5);                                         // why it is doesnt work
    }
    int num_;
};
 
int main()
{
    Foo f;
    f.wtf();
}

template <typename T>
struct test
{
    template <typename V>
    test(V p) 
    { }
};
 
template <typename T>
void foo(test<T> v)
{
}
 
int main()
{
    foo(1);
}