可变参数模板作为第一个参数

Question

我想编写一个通用模板函数，该函数接受并调用许多不同的函数，并执行其他设置和拆卸操作。函数签名在第一个参数中有所不同，例如：

void foo(int i, void* self, (*callback)(void*, int i));
void bar(bool s, bool r, void* self, (*callback)(void*, int i));

我也想选择self参数和callback，但让它们前面的参数有所不同。我知道，由于拆包的工作原理，这对于杂色模板一定很难做到；有什么办法吗？

Answer 1

根据您的用例，您可以在参数包之前接受callback和self作为第一个参数，然后按照适当的顺序合并这两个参数：

#include <tuple>
#include <functional>

template <typename F, typename... Ts>
void wrap(F f, void* self, void (*callback)(void*, int), Ts&&... ts)
{
    // change self and callback
    std::apply(f, std::tuple_cat(std::forward_as_tuple(std::forward<Ts>(ts)...),
                                 std::make_tuple(self, callback)));
}

DEMO

或根据参数在参数包中的位置提取参数：

#include <tuple>
#include <functional>

template <typename F, typename... Ts>
void wrap(F f, Ts&&... ts)
{
    constexpr int N = sizeof...(Ts);
    auto args = std::tie(ts...);

    void*& self = std::get<N-2>(args);
    void (*&callback)(void*, int) = std::get<N-1>(args);

    // change self and callback
    std::apply(f, args);
}

使用保留值类别，以上变为：

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

template <typename Tuple, std::size_t... Is>
auto take(Tuple&& t, std::index_sequence<Is...>)
{
    return std::forward_as_tuple(std::get<Is>(std::forward<Tuple>(t))...);
}

template <typename F, typename... Ts>
void wrap(F f, Ts&&... ts)
{
    constexpr int N = sizeof...(Ts);
    auto args = std::tie(ts...);

    void* self = std::get<N-2>(args);
    void (*callback)(void*, int) = std::get<N-1>(args);

    auto firsts = take(std::forward_as_tuple(std::forward<Ts>(ts)...),
                       std::make_index_sequence<N-2>{});

    // change self and callback    
    std::apply(f, std::tuple_cat(std::move(firsts), std::make_tuple(self, callback)));
}

DEMO 2

Answer 2

如果我正确理解了您的问题，那么您的问题是将可变参数模板以任何顺序用作参数，但第一个除外。好吧，幸运的是所有这些都是有效的：

template<class T, class ...Args> void call1(int y, T first, Args ... args, int x);
template<class T, class ...Args> void call2(int y, int x, T first, Args ... args);
template<class T, class ...Args> void call3(Args ... args, T first, int y, int x);
Edit:
Automatic template deduction will only work for call2
Thanks to @Human-Compiler

当然，可变参数模板是使用递归处理的，因此，为了正确处理它们，如果没有提供first参数，您还需要一个函数来调用：

void call1(int y, int x);

一个例子，它只会盲目地调用第一个x函数：

void print()
{
  std::cout << "print";
}
void call(int x)
{
  return;
}
template<class T, class ...Args> void call(int x, T f, Args ... args)
{
  if(x <= 0) return;
  f();
  call(--x, args...);
}

int main()
{
  call(3, print, print, print);
}