Question

我想写一些类似于python zip（http://docs.python.org/2/library/functions.html）的东西。 zip应该接收不同类型的可变数量的向量，并返回一个向量元组，截断到最短输入的长度。

E.g。

x = [1, 2, 3]
v = ['a', 'b']

我希望输出是矢量 [ <1, 'a'>, <2, 'b'>]

如何在C ++ 11中执行此操作？

Answer 1

热切地这样做，只有复制才很容易：

#include <vector>
#include <tuple>
#include <algorithm>

template<class... Ts>
std::vector<std::tuple<Ts...>> zip(std::vector<Ts> const&... vs){
    auto lo = std::min({vs.size()...});
    std::vector<std::tuple<Ts...>> v;
    v.reserve(lo);
    for(unsigned i = 0; i < lo; ++i)
        v.emplace_back(vs[i]...);
    return v;
}

Live example.

通过完美的转发和允许移出向量，它变得有点复杂，主要是由于帮助者：

#include <vector>
#include <tuple>
#include <algorithm>
#include <type_traits>

template<class T>
using Invoke = typename T::type;

template<class T>
using Unqualified = Invoke<std::remove_cv<Invoke<std::remove_reference<T>>>>;

template<class T>
using ValueType = typename Unqualified<T>::value_type;

template<class T>
T const& forward_index(std::vector<T> const& v, unsigned i){
    return v[i];
}

template<class T>
T&& forward_index(std::vector<T>&& v, unsigned i){
    return std::move(v[i]);
}

template<class... Vs>
std::vector<std::tuple<ValueType<Vs>...>> zip(Vs&&... vs){
    auto lo = std::min({vs.size()...});
    std::vector<std::tuple<ValueType<Vs>...>> v;
    v.reserve(lo);
    for(unsigned i = 0; i < lo; ++i)
        v.emplace_back(forward_index(std::forward<Vs>(vs), i)...);
    return v;
}

Live example.

Answer 2

以下模板功能可能是一个很好的起点。

template <typename ...Types>
auto zip(const std::vector<Types>&... values)
    -> std::vector<std::tuple<Types...>>
{
    auto size = std::min({ values.size()... });
    std::vector<std::tuple<Types...>> result;
    for (std::size_t i = 0; i != size; ++i) {
        result.emplace_back(values[i]...);
    }
    return result;
}

Answer 3

这应该做你想要的。它适用于任何范围，而不仅仅是vector。

template <typename Iterator0, typename Iterator1>
std::vector<std::tuple<
    typename Iterator0::value_type,
    typename Iterator1::value_type>>
zip(
    Iterator0 begin0, Iterator0 end0,
    Iterator1 begin1, Iterator1 end1)
{
    std::vector<std::tuple<
        typename Iterator0::value_type,
        typename Iterator1::value_type>> result;
    while (begin0 != end0 && begin1 != end1)
    {
        result.emplace_back(*begin0, *begin1);
        ++begin0;
        ++begin1;
    }
    return result;
}

你这样称呼它。

std::vector<int> x;
std::vector<double> y;
auto xy = zip(x.begin(), x.end(), y.begin(), y.end());

你可以try it out here。

可能可以修改zip以使用可变参数模板，这样就可以将任意数量的范围压缩在一起。

要进一步匹配<algorithm>标头，您可以返回void，而是选择输出将被写入的输出迭代器。

C ++ 11可变参数模板：从变量矢量列表返回元组

3 个答案: