c++ - 如何编写一个带有模板化函数参数的包装函数，它可以接受重载的成员函数？

Question

我正在使用一个遗留代码库，它使用一堆对成员函数的回调。作为重构工作的一部分，我试图包装这些回调调用。

我当前的实现是尝试使用可变参数模板函数来替换/包装绑定(bind)调用。

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)... );
}

(实际实现将在 fxn 和 obj 对象周围添加包装器类，但我删除了它以提供一个仍然显示问题的最小示例。)

这主要是可行的，但在 fxn 对象是重载成员函数的情况下会失败。在这种情况下，我收到“无法推断模板参数‘F’”/“无法推断模板参数‘F’”(GCC/Clang) 错误。这有点道理，因为可以使用具有不同参数类型的多个可能函数。

让我感到困惑的是 boost::bind 在成员解析方面没有问题——在没有包装器的原始代码中，我没有看到任何错误并且绑定(bind)进行得很顺利。示例:

#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;
}

我的主要问题:给定一个能够适当区分重载成员函数的不同版本的函数(例如但不一定限于 boost::bind)，是有一种方法可以创建一个模板化包装函数，它可以从该函数参数“完美转发”模板类型——也就是说，有没有一种方法允许编译器根据以下条件进行 F 类型推导子函数的(工作)类型推导(例如 boost::bind)？

(我确实尝试用可变预处理器宏替换 my_bind 模板函数。这解决了眼前的问题，但后来导致问题，当我尝试将 fxn 对象包装在模板类型中时。 -- 我遇到类似的“无法解析重载函数”错误。)

我的目标是 C++11，如果这有影响的话。

Answer 1

您可以尝试强制成员函数的类型，例如:

#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;
}