如何编写带有模板化函数参数的包装函数，该函数可以采用重载成员函数？

Question

I'm working with a legacy codebase which uses a bunch of callbacks to member functions. As part of a refactoring effort, I'm attempting to wrap these callback calls.

My current implementation is attempting to use a variadic template function to replace/wrap the bind call.

template< typename F, typename T, typename... Args >
auto
my_bind(F fxn, T * obj, Args&&... args)
    -> decltype( boost::bind( fxn, obj, std::forward<Args>(args)... ) )
{
    return boost::bind( fxn, obj, std::forward<Args>(args)... );
}

(The actual implementation will add wrapper classes around the fxn & obj objects, but I removed that to give a minimal example which still shows the issue.)

This mostly works, but fails where the fxn object is an overloaded member function. In this situation, I'm getting "couldn't deduce template parameter 'F'"/"couldn't infer template argument 'F'" (GCC/Clang) errors. This makes a bit of sense, as there's multiple possible functions with different parameter types which could be used.

What's confounding me is that boost::bind is not having issues with the member resolution -- in the original code without the wrapper, I don't see any errors and the binding goes well. Example:

#include <iostream>
#include <boost/bind.hpp> // Boost 1.53

template< typename F, typename T, typename... Args >
auto
my_bind(F fxn, T * obj, Args&&... args)
    -> decltype( boost::bind( fxn, obj, std::forward<Args>(args)... ) )
{
    return boost::bind( fxn, obj, std::forward<Args>(args)... );
}

class Klass {
public:
    void foo( int i ) {
       std::cout << "One param: " << i << "\n";
    }
    void foo( int i, int j ) {
       std::cout << "Two param: " << i << " " << j << "\n";
    }

    void bar( int const & i ) const {
       std::cout << "Bar One param: " << i << "\n";
    }
    int bar( float i, int j ) {
       std::cout << "Bar Two param: " << i << " " << j << "\n";
       return j;
    }
};

int main() {

    Klass k;

    auto f1 = boost::bind( &Klass::foo, &k, 1 );
    f1(); // prints "One param: 1"
    auto f2 = boost::bind( &Klass::foo, &k, 1, 2 );
    f2(); // prints "Two param: 1 2"

    //auto f1a = my_bind( &Klass::foo, &k, 1 ); // Compiler error: couldn't deduce template parameter ‘F’
    //auto f2a = my_bind( &Klass::foo, &k, 1, 2 ); // Compiler error:  couldn't deduce template parameter ‘F’

    double a = 1.1;
    int b = 3;
    //auto b1 = my_bind( &Klass::bar, &k, b ); // Should also work with const functions and const parameters
    //auto b2 = my_bind( &Klass::bar, &k, a, 2 ); // As well as non-void return types and parameter conversions
    // As well as any other member function which the underlying sub-function (here boost::bind) can take.

    return 0;
}

My main question: Given a function (such as, but not necessarily limited to boost::bind ) which is able to appropriately distinguish between different versions of an overloaded member function, is there a way to create a templated wrapper function which can "perfectly forward" the template type from that functions parameter -- that is, is there a way to permit the compiler to make the F type deduction based on the (working) type deduction of the sub-function (eg boost::bind )?

(I did try replacing the my_bind template function with a variadic preprocessor macro. This fixes the immediate problem, but results in issues later, when I attempt to wrap the fxn object in a templated type. -- I get similar "cannot resolve overloaded function" errors.)

I'm targeting C++11, if that makes a difference.

Answer 1

you may try to force the type of the member function expected like:

#include <iostream>
#include <boost/bind.hpp> // Boost 1.53

template<typename T, typename... Args>
auto
my_bind(void (T::*fxn)(Args...), T * obj, Args&&... args)
    -> decltype( boost::bind( fxn, obj, std::forward<Args>(args)... ) )
{
    return boost::bind( fxn, obj, std::forward<Args>(args)... );
}

class Klass {
public:
    void foo( int i ) {
       std::cout << "One param: " << i << "\n";
    }
    void foo( int i, int j ) {
       std::cout << "Two param: " << i << " " << j << "\n";
    }
};

int main() {

    Klass k;

    auto f1a = my_bind( &Klass::foo, &k, 2 );
    f1a(); // prints One param: 2
    auto f2a = my_bind( &Klass::foo, &k, 2, 3 );
    f2a(); // prints Two param: 2 3

    return 0;
}