序列zipfunction的C + + 11？
使用新的基于范围的for循环，我们可以编写类似的代码
for(auto x: Y) {} 哪个国际海事组织是一个巨大的改进（例如）
for(std::vector<int>::iterator x=Y.begin(); x!=Y.end(); ++x) {}
它可以用来循环两个同时循环，如Pythons zip函数？ 对于那些不熟悉Python的人来说，代码如下：
Y1 = [1,2,3] Y2 = [4,5,6,7] for x1,x2 in zip(Y1,Y2): print x1,x2
作为输出(1,4) (2,5) (3,6)
警告： boost::zip_iterator和boost::combine从Boost 1.63.0（2016年12月26日）开始将会导致未定义的行为，如果input容器的长度不一样（它可能会崩溃或迭代到最后）。
从Boost 1.56.0（2014年8月7日）开始，您可以使用boost::combine （该函数存在于早期版本中，但未公开）：
#include <boost/range/combine.hpp> #include <vector> #include <list> #include <string> int main() { std::vector<int> a {4, 5, 6}; double b[] = {7, 8, 9}; std::list<std::string> c {"a", "b", "c"}; for (auto tup : boost::combine(a, b, c, a)) { // <--- int x, w; double y; std::string z; boost::tie(x, y, z, w) = tup; printf("%d %g %s %d\n", x, y, z.c_str(), w); } }
这将打印
4 7 a 4 5 8 b 5 6 9 c 6
在早期版本中，你可以像这样自己定义一个范围：
#include <boost/iterator/zip_iterator.hpp> #include <boost/range.hpp> template <typename... T> auto zip(T&&... containers) -> boost::iterator_range<boost::zip_iterator<decltype(boost::make_tuple(std::begin(containers)...))>> { auto zip_begin = boost::make_zip_iterator(boost::make_tuple(std::begin(containers)...)); auto zip_end = boost::make_zip_iterator(boost::make_tuple(std::end(containers)...)); return boost::make_iterator_range(zip_begin, zip_end); }
用法是一样的。
您可以使用基于boost::zip_iterator的解决scheme。 让一个假的容器类保持对容器的引用，并从begin和end成员函数返回zip_iterator 。 现在你可以写
for (auto p: zip(c1, c2)) { ... }
示例实现（请testing）：
#include <iterator> #include <boost/iterator/zip_iterator.hpp> template <typename C1, typename C2> class zip_container { C1* c1; C2* c2; typedef boost::tuple< decltype(std::begin(*c1)), decltype(std::begin(*c2)) > tuple; public: zip_container(C1& c1, C2& c2) : c1(&c1), c2(&c2) {} typedef boost::zip_iterator<tuple> iterator; iterator begin() const { return iterator(std::begin(*c1), std::begin(*c2)); } iterator end() const { return iterator(std::end(*c1), std::end(*c2)); } }; template <typename C1, typename C2> zip_container<C1, C2> zip(C1& c1, C2& c2) { return zip_container<C1, C2>(c1, c2); }
我把这个可变的版本作为一个很好的练习给读者。
请参阅<redi/zip.h>以获得与range-base for一起使用的zip函数，并接受任意数量的范围，这些范围可以是右值或左值并且可以是不同的长度（迭代将在最短范围结束时停止）。
std::vector<int> vi{ 0, 2, 4 }; std::vector<std::string> vs{ "1", "3", "5", "7" }; for (auto i : redi::zip(vi, vs)) std::cout << i.get<0>() << ' ' << i.get<1>() << ' ';
打印0 1 2 3 4 5
所以我写了这个zip之前，当我无聊，我决定发布它，因为它不同于其他人，因为它不使用boost，看起来更像c + + stdlib。
template <typename Iterator> void advance_all (Iterator & iterator) { ++iterator; } template <typename Iterator, typename ... Iterators> void advance_all (Iterator & iterator, Iterators& ... iterators) { ++iterator; advance_all(iterators...); } template <typename Function, typename Iterator, typename ... Iterators> Function zip (Function func, Iterator begin, Iterator end, Iterators ... iterators) { for(;begin != end; ++begin, advance_all(iterators...)) func(*begin, *(iterators)... ); //could also make this a tuple return func; }
使用示例：
int main () { std::vector<int> v1{1,2,3}; std::vector<int> v2{3,2,1}; std::vector<float> v3{1.2,2.4,9.0}; std::vector<float> v4{1.2,2.4,9.0}; zip ( [](int i,int j,float k,float l){ std::cout << i << " " << j << " " << k << " " << l << std::endl; }, v1.begin(),v1.end(),v2.begin(),v3.begin(),v4.begin()); }
我独立地遇到了同样的问题，不喜欢上面的语法。 所以，我有一个简短的头文件，与boost zip_iterator基本相同，但是有一些macros使得语法对我更加可口：
https://github.com/cshelton/zipfor
例如，你可以做
vector<int> a {1,2,3}; array<string,3> b {"hello","there","coders"}; zipfor(i,s eachin a,b) cout << i << " => " << s << endl;
主要的语法糖是我可以从每个容器中命名元素。 我还join了一个“mapfor”，但是对于地图来说（就是元素的“.first”和“.second”）。
// declare a, b BOOST_FOREACH(boost::tie(a, b), boost::combine(list_of_a, list_of_b)){ // your code here. }
如果你有一个C ++ 14兼容的编译器（例如gcc5），你可以使用Ryan Haining在cppitertools库中提供的zip ，看起来很有前景：
array<int,4> i{{1,2,3,4}}; vector<float> f{1.2,1.4,12.3,4.5,9.9}; vector<string> s{"i","like","apples","alot","dude"}; array<double,5> d{{1.2,1.2,1.2,1.2,1.2}}; for (auto&& e : zip(i,f,s,d)) { cout << std::get<0>(e) << ' ' << std::get<1>(e) << ' ' << std::get<2>(e) << ' ' << std::get<3>(e) << '\n'; std::get<1>(e)=2.2f; // modifies the underlying 'f' array }
如果你喜欢运营商超载，这里有三种可能性。 前两个分别使用std::pair<>和std::tuple<>作为迭代器; 第三个扩展到基于范围的。 请注意，不是每个人都会喜欢这些运算符的定义，所以最好将它们保存在一个单独的名称空间中，并在要使用这些using namespace的函数（不是文件！）中using namespace 。
#include <iostream> #include <utility> #include <vector> #include <tuple> // put these in namespaces so we don't pollute global namespace pair_iterators { template<typename T1, typename T2> std::pair<T1, T2> operator++(std::pair<T1, T2>& it) { ++it.first; ++it.second; return it; } } namespace tuple_iterators { // you might want to make this generic (via param pack) template<typename T1, typename T2, typename T3> auto operator++(std::tuple<T1, T2, T3>& it) { ++( std::get<0>( it ) ); ++( std::get<1>( it ) ); ++( std::get<2>( it ) ); return it; } template<typename T1, typename T2, typename T3> auto operator*(const std::tuple<T1, T2, T3>& it) { return std::tie( *( std::get<0>( it ) ), *( std::get<1>( it ) ), *( std::get<2>( it ) ) ); } // needed due to ADL-only lookup template<typename... Args> struct tuple_c { std::tuple<Args...> containers; }; template<typename... Args> auto tie_c( const Args&... args ) { tuple_c<Args...> ret = { std::tie(args...) }; return ret; } template<typename T1, typename T2, typename T3> auto begin( const tuple_c<T1, T2, T3>& c ) { return std::make_tuple( std::get<0>( c.containers ).begin(), std::get<1>( c.containers ).begin(), std::get<2>( c.containers ).begin() ); } template<typename T1, typename T2, typename T3> auto end( const tuple_c<T1, T2, T3>& c ) { return std::make_tuple( std::get<0>( c.containers ).end(), std::get<1>( c.containers ).end(), std::get<2>( c.containers ).end() ); } // implement cbegin(), cend() as needed } int main() { using namespace pair_iterators; using namespace tuple_iterators; std::vector<double> ds = { 0.0, 0.1, 0.2 }; std::vector<int > is = { 1, 2, 3 }; std::vector<char > cs = { 'a', 'b', 'c' }; // classical, iterator-style using pairs for( auto its = std::make_pair(ds.begin(), is.begin()), end = std::make_pair(ds.end(), is.end() ); its != end; ++its ) { std::cout << "1. " << *(its.first ) + *(its.second) << " " << std::endl; } // classical, iterator-style using tuples for( auto its = std::make_tuple(ds.begin(), is.begin(), cs.begin()), end = std::make_tuple(ds.end(), is.end(), cs.end() ); its != end; ++its ) { std::cout << "2. " << *(std::get<0>(its)) + *(std::get<1>(its)) << " " << *(std::get<2>(its)) << " " << std::endl; } // range for using tuples for( const auto& d_i_c : tie_c( ds, is, cs ) ) { std::cout << "3. " << std::get<0>(d_i_c) + std::get<1>(d_i_c) << " " << std::get<2>(d_i_c) << " " << std::endl; } }
随着范围v3 ：
#include <range/v3/all.hpp> #include <vector> #include <iostream> namespace ranges { template <class T, class U> std::ostream& operator << (std::ostream& os, common_pair<T, U> const& p) { return os << '(' << p.first << ", " << p.second << ')'; } } using namespace ranges::v3; int main() { std::vector<int> a {4, 5, 6}; double b[] = {7, 8, 9}; std::cout << view::zip(a, b) << std::endl; }
输出：
[（4,7），（5,8），（6,9）]
zip_iterator可以使用zip_iterator （文档中的示例）。 它不会使用范围，但你可以使用std::for_each和一个lambda。
这是一个简单的版本，不需要提升。 它不会特别有效，因为它会创build临时值，并且不会对列表以外的容器进行概括，但是它没有依赖关系，它解决了压缩最常见的情况。
template<class L, class R> std::list< std::pair<L,R> > zip(std::list<L> left, std::list<R> right) { auto l = left.begin(); auto r = right.begin(); std::list< std::pair<L,R> > result; while( l!=left.end() && r!=right.end() ) result.push_back( std::pair<L,R>( *(l++), *(r++) ) ); return result; }
虽然其他版本更灵活，但使用列表操作符的要点往往是简单的一行。 这个版本的好处是常见的情况是简单的。
对于C ++stream处理库，我正在写一个解决scheme，它不依赖于第三方库，并且可以处理任意数量的容器。 我结束了这个解决scheme。 它与使用boost的公认解决scheme相似（如果容器长度不相等，也会导致未定义的行为）
#include <utility> namespace impl { template <typename Iter, typename... Iters> class zip_iterator { public: using value_type = std::tuple<const typename Iter::value_type&, const typename Iters::value_type&...>; zip_iterator(const Iter &head, const Iters&... tail) : head_(head), tail_(tail...) { } value_type operator*() const { return std::tuple_cat(std::tuple<const typename Iter::value_type&>(*head_), *tail_); } zip_iterator& operator++() { ++head_; ++tail_; return *this; } bool operator==(const zip_iterator &rhs) const { return head_ == rhs.head_ && tail_ == rhs.tail_; } bool operator!=(const zip_iterator &rhs) const { return !(*this == rhs); } private: Iter head_; zip_iterator<Iters...> tail_; }; template <typename Iter> class zip_iterator<Iter> { public: using value_type = std::tuple<const typename Iter::value_type&>; zip_iterator(const Iter &head) : head_(head) { } value_type operator*() const { return value_type(*head_); } zip_iterator& operator++() { ++head_; return *this; } bool operator==(const zip_iterator &rhs) const { return head_ == rhs.head_; } bool operator!=(const zip_iterator &rhs) const { return !(*this == rhs); } private: Iter head_; }; } // namespace impl template <typename Iter> class seq { public: using iterator = Iter; seq(const Iter &begin, const Iter &end) : begin_(begin), end_(end) { } iterator begin() const { return begin_; } iterator end() const { return end_; } private: Iter begin_, end_; }; /* WARNING: Undefined behavior if iterator lengths are different. */ template <typename... Seqs> seq<impl::zip_iterator<typename Seqs::iterator...>> zip(const Seqs&... seqs) { return seq<impl::zip_iterator<typename Seqs::iterator...>>( impl::zip_iterator<typename Seqs::iterator...>(std::begin(seqs)...), impl::zip_iterator<typename Seqs::iterator...>(std::end(seqs)...)); }
