Question

假设我有std::function作为N类型的输入T参数（这可以使用一些元编程魔法构建;见下文），其中N是模板参数。我想std::bind构造一个带N-1个参数的函数的第一个参数（例如myBind<...>(someValue)）。我想不出一个聪明的元编程技巧来做到这一点。有什么建议吗？

来自Lambda function with number of arguments determined at compile-time：

您可以使用嵌套的n_ary_function类型编写模板typedef。此类型可以使用如下：

template <int N> class A {
    typename n_ary_function<N, double>::type func;
};

遵循n_ary_function：

的定义

template <std::size_t N, typename Type, typename ...Types>
struct n_ary_function {
    using type = typename n_ary_function<N - 1, Type, Type, Types...>::type;
};

template <typename Type, typename ...Types>
struct n_ary_function<0, Type, Types...> {
    using type = std::function<void(Types...)>;
};

Answer 1

std::bind使用std::is_placeholder来检测占位符，这意味着您可以通过部分专门化std::bind编写自己的占位符以与std::is_placeholder一起使用：

template<int N>
struct my_placeholder { static my_placeholder ph; };

template<int N>
my_placeholder<N> my_placeholder<N>::ph;

namespace std {
    template<int N>
    struct is_placeholder<::my_placeholder<N>> : std::integral_constant<int, N> { };
}

这样就可以从整数中获取占位符。其余的只是标准的整数序列技巧：

template<class R, class T, class...Types, class U, int... indices>
std::function<R (Types...)> bind_first(std::function<R (T, Types...)> f, U val, std::integer_sequence<int, indices...> /*seq*/) {
    return std::bind(f, val, my_placeholder<indices+1>::ph...);
}
template<class R, class T, class...Types, class U>
std::function<R (Types...)> bind_first(std::function<R (T, Types...)> f, U val) {
    return bind_first(f, val, std::make_integer_sequence<int, sizeof...(Types)>());
}

Demo。 std::integer_sequence在技术上是C ++ 14，但它可以在C ++ 11中轻松实现 - 只需在SO上搜索。

Answer 2

#include <functional>
#include <cstddef>
#include <utility>
#include <tuple>

template <std::size_t N, typename Type, typename... Types>
struct n_ary_function
{
    using type = typename n_ary_function<N - 1, Type, Type, Types...>::type;
};

template <typename Type, typename... Types>
struct n_ary_function<0, Type, Types...>
{
    using type = std::function<void(Types...)>;
};

using placeholders_list = std::tuple<decltype(std::placeholders::_1)
                                   , decltype(std::placeholders::_2)
                                   , decltype(std::placeholders::_3)
                                   , decltype(std::placeholders::_4)
                                   , decltype(std::placeholders::_5)
                                   , decltype(std::placeholders::_6)
                                   , decltype(std::placeholders::_7)
                                   , decltype(std::placeholders::_8)
                                   , decltype(std::placeholders::_9)
                                   , decltype(std::placeholders::_10)
                                   >;

template <typename F>
struct arity;

template <typename R, typename... Args>
struct arity<std::function<R(Args...)>>
{
    static constexpr std::size_t value = sizeof...(Args);
};

template <typename F, typename T, std::size_t... Ints>
auto binder(F f, T t, std::index_sequence<Ints...>)
{
    return std::bind(f, t,
           typename std::tuple_element<Ints, placeholders_list>::type{}...);
}

template <typename F, typename T>
auto myBind(F f, T t)
{
    return binder(f, t, std::make_index_sequence<arity<F>::value - 1>{});
}

试验：

#include <iostream>

void foo(int a, int b, int c, int d, int e)
{
    std::cout << a << b << c << d << e << std::endl;
}

int main()
{
    n_ary_function<5, int>::type f = foo;
    n_ary_function<4, int>::type b = myBind(f, 1);
    b(2, 3, 4, 5);
}

DEMO

绑定在C ++中使用未知数量的参数进行操作

2 个答案: