Question

我想编写由参数functor（函数指针，函数对象或lambda）的参数切换的函数重载。因此，函子参数是（int）或（int，int）。

我的糟糕实施是野兔。

void function_int(int){
    return;
};

void function_int_int(int, int){
    return;
}

template <typename Functor>
boolean some_func(Functor functor) { 
    // bad implementation.
    return true;
}

int main(const int an, const char* const* const as)
{
    auto lambda_int = [&](int i) -> void {
    };
    auto lambda_int_int = [&](int i, int j) -> void {
    };

    struct functor_int {
        void operator ()(int i) {
        }
    };

    struct functor_int_int {
        void operator ()(int i, int j) {
        }
    };

    some_func(function_int);     // want true
    some_func(function_int_int); // false
    some_func(functor_int());    // true
    some_func(functor_int_int());// false
    some_func(lambda_int);       // true
    some_func(lambda_int_int);   // false
}

在C ++中有可能吗？请给我一些想法。

Answer 1

如果仿函数没有多次重载operator()，也没有默认参数，则问题只能解决。幸运的是，lambdas都是如此。

您可以通过检查T来发现lambda类型& T::operator()所需的参数。

template< typename sig >
struct ptmf_args_to_tuple;

template< typename c, typename r, typename ... a >
struct ptmf_args_to_tuple< r (c::*)( a ... ) > {
    typedef std::tuple< a ... > type;
};

template< typename c, typename r, typename ... a >
struct ptmf_args_to_tuple< r (c::*)( a ... ) const > {
    typedef std::tuple< a ... > type;
};

template< typename fn >
struct functor_args_to_tuple {
    typedef typename ptmf_args_to_tuple< decltype( & fn::operator () ) >::type type;
};

使用元函数让超载区分SFINAE：

template <typename Functor>
typename std::enable_if<
    std::tuple_size< typename functor_args_to_tuple< Functor >::type >
                   ::value == 1,
    boolean >::type
some_func(Functor functor) {

如何通过参数functor参数重载函数切换

1 个答案: