c++ - 如何: Extend C++14 template function to variadic template,参数

Question

我是一位回头的C++程序员，已经离开该语言几年了(当我上一次学习该语言时，C++ 11才开始真正地吸引人)。在过去的几年中，我一直在积极地使用Python开发数据科学应用程序。为了快速学习，我决定在C++ 14中实现Python的zip()函数，并且现在有了一个工作函数，该函数可以接受任何两个包含任何类型和“zip”的STL(和其他几个)容器它们变成元组 vector :

template <typename _Cont1, typename _Cont2>
auto pyzip(_Cont1&& container1, _Cont2&& container2) {
    using std::begin;
    using std::end;
    
    using _T1 = std::decay_t<decltype(*container1.begin())>;
    using _T2 = std::decay_t<decltype(*container2.begin())>;

    auto first1 = begin(std::forward<_Cont1>(container1));
    auto last1 = end(std::forward<_Cont1>(container1));
    auto first2 = begin(std::forward<_Cont2>(container2));
    auto last2 = end(std::forward<_Cont2>(container2));
    
    std::vector<std::tuple<_T1, _T2>> result;
    result.reserve(std::min(std::distance(first1, last1), std::distance(first2, last2)));
    for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
        result.push_back(std::make_tuple(*first1, *first2));
    }
    return result;
}

例如，以下代码(摘自运行xeus-cling C++ 14内核的Jupyter笔记本中的代码单元)

#include <list>
#include <xtensor/xarray.hpp>

list<int> v1 {1, 2, 3, 4, 5};
xt::xarray<double> v2 {6.01, 7.02, 8.03};
auto zipped = pyzip(v1, v2);

for (auto tup: zipped)
    cout << '(' << std::get<0>(tup) << ", " << std::get<1>(tup) << ") ";

产生以下输出:

(1, 6.01) (2, 7.02) (3, 8.03)

我想扩展我的功能，以容纳任意数量的任意类型的容器，并且花了一些时间研究可变参数模板，但令我感到尴尬的是，我并没有连接点。我如何才能泛化此函数以采用任意数量的包含任意数据类型的任意容器类型？我并不一定要寻找所需的确切代码，但在这种情况下，我确实可以使用一些帮助来解决如何利用可变参数模板。
此外，我对代码的任何批评也将不胜感激。

Answer 1

可变参数模板的机制与Python传递函数位置参数然后将这些位置参数扩展为值序列的功能不太相似。 C++的机制更强大，更基于模式。
因此，让我们从头开始。您想采用任意范围的范围(容器过于局限):

template <typename ...Ranges>
auto pyzip(Ranges&& ...ranges)

此处使用 ...指定包的声明。这个特定的函数声明声明了两个“包”:一个名为 Ranges的类型的包和一个名为 ranges的参数包。
因此，您需要做的第一件事就是获得一系列的开始和结束迭代器。由于这些迭代器可以是任意类型，因此数组将不起作用。它必须存储在 tuple中。需要通过获取 ranges，获取该元素并在其上调用 begin来初始化元组的每个元素。这是您的操作方式:

auto begin_its = std::make_tuple(begin(std::forward<Ranges>(ranges))...);

...的这种用法称为包扩展。左侧的表达式包含一个或多个包。然后 ...将该表达式转换为逗号分隔的值序列，用该包中列出该包的每个对应成员替换。被扩展的表达式是 begin(std::forward<Ranges>(ranges))。而且我们在这里同时使用了 ranges和 Ranges，因此这两个包都被一起展开(并且大小必须相同)。
我们将此包扩展为 make_tuple的参数，以便该函数为包中的每个元素获取一个参数。
当然，同样的东西也适用于 end。
接下来，您要将每个范围中的元素的拷贝(？)存储在 vector<tuple>中。好吧，这要求我们首先弄清楚范围的值类型是什么。通过在示例中使用的typedef进行另一个包扩展，这很容易:

using vector_elem = std::tuple<std::decay_t<decltype(*begin(std::forward<Ranges>(ranges)))>...>;
std::vector<vector_elem> result;

请注意，在这种情况下， ...不适用于“表达式”，但它具有相同的作用:对 std::decay_t的每个元素重复 ranges部分。
接下来，我们需要计算最终列表的大小。那是...实际上出奇的困难。有人可能会认为您可以只使用 begin_its和 end_its，然后对其进行迭代，或者对它们使用某些pack扩展名。但是不，C++不允许您执行任何一个操作。这些元组不是包，您不能(轻松)将它们这样。
实际上，只需重新计算begin/end迭代器并采用一个表达式，就可以轻松实现差异。

auto size = std::min({std::distance(begin(std::forward<Ranges>(ranges)), end(std::forward<Ranges>(ranges)))...});
result.reserve(std::size_t(size));

好吧，在代码行方面“更轻松”，而不是那么易读； std::min在此处采用值的初始化列表来计算最小值。
对于我们的循环，与其循环直到迭代器达到最终状态，不如循环计数。
但这实际上只是解决了最后一个问题。即，我们有这个迭代器元组，并且我们需要对其成员执行2个操作:解引用和递增。而且我们在做什么并不重要。在C++中同样困难。
哦，这完全可行。您只需要一个新功能。
看，您无法使用运行时索引访问 tuple的元素。而且您不能循环编译时值。因此，您需要某种方式来获得一个不包含参数或类型但包含整数索引的包。可以将这组索引解压缩到 get<Index>调用中，以便 tuple访问其内容。
C++ 17为我们提供了一个方便的 std::apply函数来完成这种事情。不幸的是，这是C++ 14，因此我们必须编写一个:

namespace detail {
template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
{
    return f(std::get<I>(std::forward<Tuple>(t))...);
}
}  // namespace detail
 
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t)
{
    return detail::apply_impl(
        std::forward<F>(f), std::forward<Tuple>(t),
        std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
}

这里的 apply接受一个函数和一个元组，并将该元组解压缩到函数的参数中，并返回该函数返回的内容。
因此，回到我们的函数中，我们可以使用 apply进行所需的操作:间接，然后递增每个元素。通用lambda允许我们有效地处理通过 vector将值插入 emplace_back:

for (decltype(size) ix = 0; ix < size; ++ix)
{
  apply([&result](auto&& ...its) mutable
  {
    result.emplace_back(*its...); //No need for redundant `make_tuple`+copy.
  }, begin_its);

  apply([](auto& ...its)
  {
    int unused[] = {0, (++its, 0)...};
  }, begin_its);
}

unused及其初始化程序是C++仅对包中的每个项目执行表达式而丢弃结果的一种困惑方式。不幸的是 it's the most straightforward way to do that in C++14。
Here's the whole working example。