c++ - 推导可变函数内不同参数包中的两个不同的已知类型变量

我有以下代码：

template <typename... Type1, typename... Type2>
void foo(const Type1&&... t1, Type2&&... t2)
{
    int len = sizeof...(Type1);
    cout << len << endl;
    int len1 = sizeof...(Type2);
    cout << len1 << endl;
}

int main()
{
    foo(1, 2, 4.5, 5.5);

    return 0;
}

调用foo()会将Type1推为空，将Type2推为{int, int, double, double}，而我想拥有的是Type1为{int, int}和Type2为{double, double}。 >并像上面的代码中那样调用std::tuple函数？

编辑：

为了更清楚地说明我要实现的目标，这里有一个解释。我想创建一个函数，使用户每次都能以偶数对的形式传递任意数量的两种类型的变量。假设foo() foo(Type1 x, Type1 y, Type1 z, Type1 ..., Type2 XX, Type2 YY, Type2 ZZ, Type2 ...);的变量将始终是Type1引用，而const的变量仅是引用，因此该函数最终将具有以下形式：Type2。在函数中，我将使用foo(const Type1& x, const Type1& y, ..., Type2& XX, Type2& YY, ...)变量应用一些计算，然后通过Type1变量返回相应的结果。我知道使用任何容器结构都会使我的生活更轻松，但是不幸的是，我无法采用该解决方案。因此，尽管我不是一个有经验的人，但我认为使用可变参数函数是必经之路，对吗？

最佳答案

不，编译器无法理解您的想法。

您可以将一包类型分成两半：

template<class...>struct types{using type=types;};

template<class lhs, class rhs>struct cat;
template<class lhs, class rhs>using cat_t=typename cat<lhs,rhs>::type;

template<class...lhs, class...rhs>
struct cat<types<lhs...>,types<rhs...>>:
  types<lhs...,rhs...>
{};

template<class types, size_t n>
struct split {
private:
  using s0 = split<types,n/2>;
  using r0 = typename s0::lhs;
  using r1 = typename s0::rhs;
  using s1 = split<r1,n-n/2>;
  using r2 = typename s1::lhs;
public:
  using lhs = cat_t<r0,r2>;
  using rhs = typename s1::rhs;
};
template<class Types>
struct split<Types, 0>{
  using lhs=types<>;
  using rhs=Types;
};
template<class T0,class...Ts>
struct split<types<T0,Ts...>,1>{
  using lhs=types<T0>;
  using rhs=types<Ts...>;
};

然后我们使用它将foo参数分成两个包：

template<class types>
struct foo2_t;
template<class... T0s>
struct foo2_t<types<T0s...>>{
  template<class... T1s>
  void operator()(T0s&&... t0s, T1s&&... t1s) const {
    std::cout << sizeof...(T0s) << '\n';
    std::cout << sizeof...(T1s) << '\n';
  }
};

template <class... Ts>
void foo(Ts&&... ts) {
  using s = split< types<Ts...>, sizeof...(Ts)/2 >;
  foo2_t<typename s::lhs>{}( std::forward<Ts>(ts)... );
}

live example

如果您希望编译器执行不同的操作（例如，对相同类型进行批处理，或考虑其他任何操作），则可以使用其他（但仍相似）的技术。

关于c++ - 推导可变函数内不同参数包中的两个不同的已知类型变量，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/29425671/

type1

c++ - 推导可变函数内不同参数包中的两个不同的已知类型变量