【问题标题】：Deducing Multiple Parameter Packs推导多个参数包
【发布时间】：2019-02-09 14:40:17
【问题描述】：

背景

我正在尝试为纯模板单元测试库编写一些模板函数，特别是针对 Qt。

问题

在这个库中，我有一个可变参数模板，它接收可变数量的对象和函子（实际上是 Qt5 信号），它们总是彼此相邻配对，如 QObject, signal, etc... 然后理想地跟随可变数量的信号参数。

所需的解决方案

// implementation.h

template <typename T, typename U, typename... Sargs, typename... Fargs>
void test_signal_daisy_chain(T* t,  void(T::*t_signal)(Fargs...), 
                             U* u,  void(U::*u_signal)(Fargs...), 
                             Sargs... sargs, 
                             Fargs... fargs) {...}

// client.cpp

test_signal_daisy_chain(object, &Object::signal1, 
                        object, &Object::signal2, 
                        object, &Object::signal3, 
                        1, 2, 3); // where the signals are defined as void(Object::*)(int, int, int)

其中Fargs...对应t_signal和u_signal中的参数以及传递给这个函数进行测试的参数，Sargs...对应可变数量的QObject和信号成员函数(void(T::*)(Fargs...)) 发出用于明确的测试目的。

不出所料，由于“模板参数推导/替换失败”，我得到“没有匹配函数”，并且我的 ClangCodeModel 插件警告我应该有 6 个参数，其中给出了 8 个。

工作（丑陋的）解决方案

// implementation.h
template <typename... Fargs>
struct wrapper
{
    template <typename T, typename U, typename... Sargs>
    void test_signal_daisy_chain(Fargs... fargs, 
                                 T* t,  void(T::*t_signal)(Fargs...), 
                                 U* u,  void(U::*u_signal)(Fargs...), 
                                 Sargs... sargs) {...}

// client.cpp

wrapper<int, int, int>::test_signal_daisy_chain(1, 2, 3, 
                                                object, &Object::signal1,
                                                object, &Object::signal2,
                                                object, &Object::signal3);

我不满足于必须在函数调用的开头和包装模板类型参数中显式定义变量函数参数。事实上，我最初很惊讶不能仅仅通过它们与函子的可变参数相匹配这一事实来推断。我愿意使用包装器函数而不是包装器类，因为我已经设置了一个详细的命名空间，为了提供一个干净且用户友好的 API，我愿意为它弄乱。

注意：信号参数可以是任何地方，从原语到用户定义的类型到 POD 结构到模板类，所有的长度都是可变的。

编辑 1：c++11 是一项硬性要求，因此您可以在答案中保留 >c++11 功能，只要它们有一些 c++ 11 解决方法，即auto... 很容易修复，auto myFunction = []() constexpr {...}; 更不用说。如果使用 if constexpr 而不是递归的 template <std::size_t> 帮助函数可以节省空间并提供更简洁、完整和面向未来的答案，那么请选择您认为最好的标准。

【问题讨论】：

您希望如何在所需的解决方案中将Sargs 与Fargs 分隔开？
Sargs 应该被 T （回想起来应该继承 QObject）和另一个 void(T::*)(Fargs) 分开。我需要递归地遍历它们，所以我最终用test_signal_daisy_chain(u, u_signal, sargs..., fargs...) 再次调用它。事后看来，我可能需要在我的参数中声明 F f, Fargs... fargs 以便我的扩展工作。
我看到它按原样工作的唯一方法是签名void test(T *t, void (T::*t_signal)(Fargs...), U*u, void (U::*u_signal)(Fargs...), Args... args)，然后将Args 包装在一个类型元组中，并对其进行操作以提取Sargs 类型（通过切断Fargs 结束）和其他对象信号对（如果有）。如果您计划任何重载，这当然行不通。
@KubaOber 我同意，我认为唯一能给我一个漂亮干净的前端 API 的解决方案是需要对元组做一些工作。我可能会开始着手实现我自己的实现，但是如果您有一个答案，即 1. 具有类似 method(Object, ptr, Object, ptr, .../* variable amount of "Object, ptr", Fargs...) 的样式并且 2.不需要显式类型声明或包装器参数，那么我会更多很高兴看到它。

标签： c++ qt c++11 templates variadic-functions

【解决方案1】：

最简单的做法是一开始就将参数打包成一个元组，然后将元组传递给test_signal_daisy_chain_impl：

template < typename... Fargs, 
          typename T, typename... Sargs>
void test_signal_daisy_chain_impl(const std::tuple<Fargs...> & fargs, 
                                  T* t, void(T::*t_signal)(Fargs...),
                                  Sargs &&... sargs)
{
    // apply unpacks the tuple
    std::apply([&](auto ...params) 
               {
                   (t->*t_signal)(params...);
               }, fargs);

    // Although packed into the tuple, the elements in
    // the tuple were not removed from the parameter list,
    // so we have to ignore a tail of the size of Fargs.
    if constexpr (sizeof...(Sargs) > sizeof...(Fargs))
       test_signal_daisy_chain_impl(fargs, std::forward<Sargs>(sargs)...);
}

// Get a tuple out of the last I parameters
template <std::size_t I, typename Ret, typename T, typename... Qargs>
Ret get_last_n(T && t, Qargs && ...qargs)
{
    static_assert(I <= sizeof...(Qargs) + 1, 
                  "Not enough parameters to pass to the signal function");
    if constexpr(sizeof...(Qargs)+1  == I)
       return {std::forward<T>(t), std::forward<Qargs>(qargs)...};
    else
       return get_last_n<I, Ret>(std::forward<Qargs>(qargs)...);
}    

template <typename T, typename... Fargs, 
          typename... Qargs>
void test_signal_daisy_chain(T* t, void(T::*t_signal)(Fargs...),
                             Qargs&&... qargs)
{
    static_assert((sizeof...(Qargs) - sizeof...(Fargs)) % 2 == 0,
                  "Expecting even number of parameters for object-signal pairs");
    if constexpr ((sizeof...(Qargs) - sizeof...(Fargs)) % 2 == 0) {
        auto fargs = get_last_n<sizeof...(Fargs), std::tuple<Fargs...>>(
                                 std::forward<Qargs>(qargs)...);
        test_signal_daisy_chain_impl(fargs, t, t_signal, 
                                     std::forward<Qargs>(qargs)...);
    }
}

及用法：

class Object {
public:
    void print_vec(const std::vector<int> & vec)
    {
        for (auto elem: vec) std::cout << elem << ", ";
    }
    void signal1(const std::vector<int> & vec) 
    { 
        std::cout << "signal1(";
        print_vec(vec);
        std::cout << ")\n";
    }
    void signal2(const std::vector<int> & vec) 
    { 
        std::cout << "signal2(";
        print_vec(vec);
        std::cout << ")\n";
    }
    void signal_int1(int a, int b) 
    { std::cout << "signal_int1(" << a << ", " << b << ")\n"; }
    void signal_int2(int a, int b) 
    { std::cout << "signal_int2(" << a << ", " << b << ")\n"; }
    void signal_int3(int a, int b) 
    { std::cout << "signal_int3(" << a << ", " << b << ")\n"; }
};

int main()
{
   Object object;
   test_signal_daisy_chain(&object, &Object::signal1,
                           &object, &Object::signal2 ,
                           std::vector{1,2,3});
   test_signal_daisy_chain(&object, &Object::signal_int1,
                           &object, &Object::signal_int2 ,
                           &object, &Object::signal_int3,
                           1,2);
}

编辑 1

由于 C++11 是一个硬约束，因此基于相同的原理，有一个更丑陋的解决方案。 std::apply 和 std::make_index_sequence 之类的东西必须实现。使用重载代替if constexpr(....)：

template <std::size_t ...I>
struct indexes
{
    using type = indexes;
};

template<std::size_t N, std::size_t ...I>
struct make_indexes
{
    using type_aux = typename std::conditional<
                    (N == sizeof...(I)),
                    indexes<I...>,
                    make_indexes<N, I..., sizeof...(I)>>::type;
    using type = typename type_aux::type;
};

template <typename Tuple, typename T, typename Method, std::size_t... I>
void apply_method_impl(
    Method t_signal, T* t, const Tuple& tup, indexes<I...>)
{
    return (t->*t_signal)(std::get<I>(tup)...);
}

template <typename Tuple, typename T, typename Method>
void apply_method(const Tuple & tup, T* t, Method t_signal)
{
      apply_method_impl(
        t_signal, t, tup,
        typename make_indexes<
             std::tuple_size<Tuple>::value>::type{});
}

template < typename... Fargs,  typename... Sargs>
typename std::enable_if<(sizeof...(Fargs) == sizeof...(Sargs)), void>::type 
test_signal_daisy_chain_impl(const std::tuple<Fargs...> & , 
                             Sargs &&...)
{}

template < typename... Fargs, 
          typename T, typename... Sargs>
void test_signal_daisy_chain_impl(const std::tuple<Fargs...> & fargs, 
                                  T* t, void(T::*t_signal)(Fargs...),
                                  Sargs &&... sargs)
{
    apply_method(fargs, t, t_signal);

    // Although packed into the tuple, the elements in
    // the tuple were not removed from the parameter list,
    // so we have to ignore a tail of the size of Fargs.
    test_signal_daisy_chain_impl(fargs, std::forward<Sargs>(sargs)...);
}

// Get a tuple out of the last I parameters
template <std::size_t I, typename Ret, typename T, typename... Qargs>
typename std::enable_if<sizeof...(Qargs)+1  == I, Ret>::type
get_last_n(T && t, Qargs && ...qargs)
{
    return Ret{std::forward<T>(t), std::forward<Qargs>(qargs)...};
}    

template <std::size_t I, typename Ret, typename T, typename... Qargs>
typename std::enable_if<sizeof...(Qargs)+1  != I, Ret>::type
get_last_n(T && , Qargs && ...qargs)
{
    static_assert(I <= sizeof...(Qargs) + 1, "Not enough parameters to pass to the singal function");
    return get_last_n<I, Ret>(std::forward<Qargs>(qargs)...);
}    

template <typename T, typename... Fargs, 
          typename... Qargs>
void test_signal_daisy_chain(T* t, void(T::*t_signal)(Fargs...),
                             Qargs&&... qargs)
{
    static_assert((sizeof...(Qargs) - sizeof...(Fargs)) % 2 == 0,
                  "Expecting even number of parameters for object-signal pairs");
    auto fargs = get_last_n<sizeof...(Fargs), std::tuple<Fargs...>>(
                             std::forward<Qargs>(qargs)...);
    test_signal_daisy_chain_impl(fargs, t, t_signal, 
                                     std::forward<Qargs>(qargs)...);
}

编辑 2

可以通过将所有参数存储在一个元组中来避免运行时递归。以下test_signal_daisy_chain_flat() 正是这样做的，同时保留了与test_signal_daisy_chain() 相同的界面：

template <typename Fargs, typename Pairs, std::size_t ...I>
void apply_pairs(Fargs && fargs, Pairs && pairs, const indexes<I...> &)
{
    int dummy[] = {
        (apply_method(std::forward<Fargs>(fargs),
                      std::get<I*2>(pairs),
                      std::get<I*2+1>(pairs)),
         0)...
    };
    (void)dummy;
}
template <typename T, typename... Fargs, 
          typename... Qargs>
void test_signal_daisy_chain_flat(T* t, void(T::*t_signal)(Fargs...),
                                  Qargs&&... qargs)
{
    static_assert((sizeof...(Qargs) - sizeof...(Fargs)) % 2 == 0,
                  "Expecting even number of parameters for object-signal pairs");
    auto fargs = get_last_n<sizeof...(Fargs), std::tuple<Fargs...>>(
                             std::forward<Qargs>(qargs)...);
    std::tuple<T*, void(T::*)(Fargs...), const Qargs&...> pairs{
        t, t_signal, qargs...};
    apply_pairs(fargs, pairs,
                typename make_indexes<(sizeof...(Qargs) - sizeof...(Fargs))/2>
                ::type{});
}

注意事项：

未断言参数对匹配。编译器根本无法编译（可能深度递归）。
传递给函数的参数的类型是从第一个函数的签名中推断出来的，无论尾随参数的类型如何 - 尾随参数都被转换为所需的类型。
所有函数都必须具有相同的签名。

【讨论】：

我很抱歉没有让自己更清楚，Fargs 每个函数（指针）都是相等的，即信号 1、信号 2 和信号 3 都具有相同的签名，我们还将通过以下方式测试它们的连接根据Fargs传入数据。例如，如果函数签名为void(T::*)(int, int, int)，我们为Fargs 传入三个整数。 Sargs 对应于可变数量的 QObjects 及其信号，在这种情况下是成员函数指针，因此 Sargs 分别像 QObject, fptr, ..., Fargs...) 一样解包。
@jfhcs 修复起来很简单，但我不在电脑附近，无法验证。未经测试已修复。
不着急，我最终会寻找符合 2 个标准的解决方案：
@jfhcs 进行了重大更改以符合明确的要求。接受元组的函数现在名称中有_impl
@jfhcs 我在答案末尾添加了一个非递归变体，名为test_signal_daisy_chain_flat。为了避免混淆，我用了一个新名字，但基本上和test_signal_daisy_chain的界面是一样的。

【解决方案2】：

template<class T>
struct tag_t { using type=T; };
template<class Tag>
using type_t = typename Tag::type;

template<class T>
using no_deduction = type_t<tag_t<T>>;

template <typename T, typename U, typename... Sargs, typename... Fargs>
void test_signal_daisy_chain(
  T* t, void(T::*t_signal)(Sargs...),
  U* u, void(U::*u_signal)(Fargs...),
  no_deduction<Sargs>... sargs,
  no_deduction<Fargs>... fargs)

我认为t_signal 中的Fargs... 是错字，应该是Sargs。

如果没有，你就有麻烦了。没有“先扣后扣”的规定。

您可以在c++14 中做的一件事是让函数返回一个函数对象：

template <typename T, typename U, typename... Fargs>
auto test_signal_daisy_chain(
  T* t, void(T::*t_signal)(Fargs...),
  U* u, void(U::*u_signal)(Fargs...),
  no_deduction<Fargs>... fargs
) {
  return [=](auto...sargs) {
    // ...
  };
}

然后使用看起来像：

A a; B b;
test_signal_daisy_chain( &a, &A::foo, &b, &B::bar, 1 )('a', 'b', 'c');

在c++11 中执行此操作可以使用手动编写的函数对象。

【讨论】：

抱歉，t_signal 中的 Fargs.. 应该匹配 u_signal 的参数，而 Sargs 对应于可变数量的 QObject 和成员函数对。我会更新克莱尔蒂。
@jfhcs 我想我涵盖了那个案例。我不得不交换fargs 和sargs 的顺序
我的测试用例似乎没有任何运气。此外，我对此的硬性要求之一是它遵循具有QObject, functor, QObject, functor 的Qt 约定，就像QObject::connect 函数一样。感谢您的耐心等待，尽管我很感谢您的帮助。
@jfhcs 你是对的，那是行不通的。添加了替代解决方法。