推导多个参数包

问题描述 投票：8回答：2

Background

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

Problem

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

Desired Solution

// 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个被给出。

Working (ugly) solution

// 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>辅助函数可以节省空间并提供更简洁，完整和面向未来的答案，那么请选择您认为最合适的标准。

c++ qt c++11 templates variadic-functions
2个回答
4
投票

最简单的方法是将参数打包到开头的元组中，并将元组传递给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{});
}

注意事项：

  1. 不断言参数对匹配。编译器无法编译（可能深入递归）。
  2. 传递给函数的参数类型是从第一个函数的签名推导出来的，无论尾随参数的类型如何 - 尾随参数都转换为所需类型。
  3. 所有功能都必须具有相同的签名。
4
投票
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)

我认为Fargs...中的t_signal是一个错字，应该是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中执行此操作。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.