Sequence-zip function for c++11?

by

Warning: boost::zip_iterator and boost::combine as of Boost 1.63.0 (2016 Dec 26) will cause undefined behavior if the length of the input containers are not the same (it may crash or iterate beyond the end).

Starting from Boost 1.56.0 (2014 Aug 7) you could use boost::combine (the function exists in earlier versions but undocumented):

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

This would print 

4 7 a 4
5 8 b 5
6 9 c 6

In earlier versions, you could define a range yourself like this:

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

The usage is the same.

More Related Contents:

  1. C++ Need help for a homework program that reads in a list of doubles from a file and add a string to each double
  2. How to enforce move semantics when a vector grows?
  3. Is signed integer overflow still undefined behavior in C++?
  4. using extern template (C++11)
  5. C++’s most vexing parse again [duplicate]
  6. Flattening iterator
  7. What are the correct link options to use std::thread in GCC under linux?
  8. What new capabilities do user-defined literals add to C++?
  9. What is the logic behind the “using” keyword in C++?
  10. constexpr overloading
  11. C++11: Correct std::array initialization?
  12. Alias template specialisation
  13. How does std::move() transfer values into RValues?
  14. What do compilers do with compile-time branching?
  15. std::bind a bound function
  16. What are declarations and declarators and how are their types interpreted by the standard?
  17. Which std::async implementations use thread pools?
  18. C++ how to generate all the permutations of function overloads?
  19. What expressions yield a reference type when decltype is applied to them?
  20. How can I have multiple parameter packs in a variadic template?
  21. Why is the new random library better than std::rand()?
  22. Different ways of initializing an object in c++
  23. What is the purpose of the “final” keyword in C++11 for functions?
  24. How to make a variadic is_same?
  25. How do shared pointers work?
  26. Memory alignment : how to use alignof / alignas?
  27. Check if a type is from a particular namespace
  28. How does =delete on destructor prevent stack allocation?
  29. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  30. Why can’t C++11 move a noncopyable functor to a std::function?

Leave a Comment