3

我有以下问题。假设您想编写一个可以采用 lambda 表达式的通用函数。我知道，如果参数的类型是 std::function，那么我不仅可以使用 lambda，还可以使用函数，甚至可以使用指向函数的指针。所以在第一步，我做了以下事情：

void print(std::function<void(int, int)> fn) {
  fn(1,2);
}

int main() {

  print([](int i, int j) { std::cout << j <<','<<i<<'\n'; });
  return 0;
}

现在的问题是我想让这个函数通用，这意味着我不希望 lambda 表达式只有两个参数。所以我尝试将 print 函数的签名更改为更通用的东西，例如：

template <class function_type>
void print(function_type fn);

但现在的问题是该函数接受 ANY 对象，我对此不满意。但主要问题是，我不知道对象 fn 可以接受多少个参数。

因此，在某种程度上，我正在寻找一种编译时方法来确定 fn 有多少个参数，并在可能的情况下将 fn 的类型更改为 std::function。然后，鉴于我知道 fn 接受的参数数量，是否有一种通用方法可以打包任意数量的参数以传递给 fn？我什至不知道这在 C++11 中是否可行。我的意思是，考虑到参数的数量，有没有办法打包参数以传递给 fn？所以如果有两个论点，那么我会打电话给

fn(arg1, arg2);

如果有三个：

fn(arg1, arg2, arg3);

等等。

谢谢大家的洞察力。

啊

4

3 回答 3

2

以下片段可能有用。

std::function这给出了 a接受的参数数量

template <typename Signature>
struct count_args;

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

例如以下代码编译（clang 3.2、gcc 4.7.2 和 icc 13.1.0）

static_assert(count_args<std::function<void()        >>::value == 0, "Ops!");
static_assert(count_args<std::function<void(int)     >>::value == 1, "Ops!");
static_assert(count_args<std::function<void(int, int)>>::value == 2, "Ops!");

据我了解，您想调用传递正确数量参数的函数对象，对吗？然后对于每个参数，我们需要提供一个可转换为其类型的值。具有这种普遍性的解决方案非常困难（甚至是不可能的）。因此，我将提出两种选择。

1每个参数都是其类型的值初始化对象。（这就是ecatmur 的 建议。）

template <typename Ret, typename... Args>
Ret call(const std::function<Ret(Args...)>& f) {
    return f(Args{}...); // for the intel compiler replace {} with ()
}

2给定一个固定值，所有参数都从该值隐式初始化：

template <typename Ret, typename... Args, typename Val, typename... Vals>
typename std::enable_if<sizeof...(Args) == sizeof...(Vals), Ret>::type
call(const std::function<Ret(Args...)>& f, const Val&, const Vals&... vals) {
    return f(vals...);
}

template <typename Ret, typename... Args, typename Val, typename... Vals>
typename std::enable_if<(sizeof...(Args) > sizeof...(Vals)), Ret>::type
call(const std::function<Ret(Args...)>& f, const Val& val, const Vals&... vals) {
    return call(f, val, val, vals...);
}

这三个重载是明确的，可以用作以下示例所示：

{
    std::function<char()> f = []() -> char {
        std::cout << "f() ";
        return 'A';
    };
    std::cout << call(f)    << std::endl; // calls f()
    std::cout << call(f, 0) << std::endl; // calls f()
}
{
    std::function<char(int)> f = [](int i) -> char {
        std::cout << "f(" << i << ") ";
        return 'B';
    };
    std::cout << call(f)    << std::endl; // calls f(0)
    std::cout << call(f, 1) << std::endl; // calls f(1)
}
{
    std::function<char(int, int)> f = [](int i, int j) -> char {
        std::cout << "f(" << i << "," << j << ") ";
        return 'C';
    };
    std::cout << call(f)    << std::endl; // calls f(0, 0)
    std::cout << call(f, 2) << std::endl; // calls f(2, 2)
}
于 2013-04-13T19:42:46.310 回答
0

要确定可调用的签名，您可以使用Inferring the call signature of a lambda 或 "make_function" 的任意可调用的解决方案。然后，您可以将 callable 打包成std::function，或创建标签并使用参数推断：

template<typename T> struct tag {};

template<typename F, typename... Args>
void print_impl(F &&fn, tag<void(Args...)>) {
  fn(Args{}...);
}

template<typename F>
void print(F &&fn) {
  print_impl(std::forward<F>(fn), tag<get_signature<F>>{});
}

请注意，这使用了值初始化的参数；如果你想要更复杂的东西，你可以构建一个std::tuple<Args...>并传递它，在每个“解包”一个元组时调用它来调用一个匹配的函数指针。

于 2013-04-04T09:34:43.943 回答
0

是的，您可以fn使用可变参数模板打包任意数量的参数。

template <class function_type, class... Args>
void print(function_type fn, Args... args)
{
    //Call fn with args
    fn(std::forward<Args>(args...));
}

要找出参数包中有多少个 args，您可以使用sizeof...(args).

于 2013-04-04T08:45:33.983 回答