C++ 11 Mẫu biến thể: trả về tuple từ danh sách biến số vectơ

Question

Tôi muốn viết một cái gì đó tương tự như mã zip python (http://docs.python.org/2/library/functions.html). zip phải có số lượng vectơ khác nhau của các loại khác nhau và nó trả về một vector của bộ dữ liệu, được cắt ngắn theo độ dài của đầu vào ngắn nhất.

Ví dụ:

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

Tôi muốn đầu ra là một vector của [ <1, 'a'>, <2, 'b'>]

Làm thế nào để làm điều này trong C++ 11?

Answer 1

Việc làm này hăm hở và chỉ với sao chép là khá dễ dàng:

#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.

Với chuyển tiếp hoàn hảo và cho phép di chuyển ra khỏi vector, nó trở thành chỉ là một chút phức tạp hơn, chủ yếu là do người giúp đỡ:

#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

Điều này sẽ làm những gì bạn muốn. Nó hoạt động cho bất kỳ phạm vi nào trái ngược với chỉ 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; 
} 

Bạn gọi nó như thế này.

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

Bạn có thể try it out here.

Có thể sửa đổi zip để sử dụng các mẫu có vectơ, để bạn có thể nén bất kỳ số lượng dải ô nào lại với nhau.

Để tiếp tục khớp với tiêu đề <algorithm>, bạn có thể trả lại void và thay vào đó hãy dùng trình lặp đầu ra để ghi kết quả đầu ra.

Answer 3

Chức năng mẫu sau có thể là điểm khởi đầu tốt.

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; 
}