pkl>for( auto i1 : a, auto i2 : b, auto i3 : c) {
    
pkl>}
pkl>

#include <functional>
#include <numeric>
#include <iostream>
#include <tuple>
#include <vector>

template <typename...T>
class ZipIterator
{
public:

   using reference = std::tuple<decltype(*std::declval<T>())...>;

public:

   ZipIterator(T&&...i) : m(std::forward<T>(i)...) { };

   reference operator * () const { return std::tie(*std::get<T>(m)...); }
   ZipIterator operator ++ () { char c[]{ (++std::get<T>(m), 0)... }; return *this; }

   bool operator == (const ZipIterator& other) const {
      const bool eq[]{ (std::get<T>(m) == std::get<T>(other.m))... };
      return std::accumulate(std::begin(eq), std::end(eq), false, std::logical_or<>());
   }
   bool operator != (const ZipIterator& other) const { return !(*this == other); }

private:
   std::tuple<T...> m;
};

template <typename T>
struct IteratorRange
{
   T m_begin;
   T m_end;

   const T& begin() const { return m_begin; }
   const T& end() const { return m_end; }
};

template <typename...T>
using ZipRange = IteratorRange<ZipIterator<decltype(std::begin(std::declval<T>()))...>>;

template <typename...T>
ZipRange<T...> make_zip_range(T&&...t) { return {{std::begin(t)...},{ std::end(t)...} }; }

int main()
{
   std::vector<int> a { 1, 2, 3 };
   std::vector<std::string> b { "hello", "world", "foo", "bar" };
   int c[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };

   for (auto&& entry : make_zip_range(a, b, c))
   {
      std::cout << std::get<0>(entry) << ", " << std::get<1>(entry) << ", " << std::get<2>(entry) << std::endl;
   }
}

R>   for (auto&& entry : make_zip_range(a, b, c))
R>   {
R>      std::cout << std::get<0>(entry) << ", " << std::get<1>(entry) << ", " << std::get<2>(entry) << std::endl;
R>   }
R>}

   for (auto&& entry : make_zip_range(a, b, c))
   {
      std::cout << std::get<0>(entry) << ", " << std::get<1>(entry) << ", " << std::get<2>(entry) << std::endl;
   }

    auto ia = a.begin();
    auto ib = b.begin();
    auto ic = c.begin();

    for (;;) {
        bool in_a = ia != a.end();
        bool in_b = ib != b.end();
        bool in_c = ic != c.end();
        if (!(in_a || in_b || in_c)) break;

        if (in_a)
            std::cout << *ia;
        else
            std::cout << "-";

        if (in_b)
            std::cout << ", " << (*ib).c_str();
        else
            std::cout << ", -";

        if (in_c)
            std::cout << ", " << *ic;
        else
            std::cout << ", -";

        std::cout << std::endl;

        if (in_a) ++ia;
        if (in_b) ++ib;
        if (in_c) ++ic;
    };

pkl>for( auto i1 : a, auto i2 : b, auto i3 : c) {
    
pkl>}
pkl>

#include <boost/range/combine.hpp>

// ...

std::vector<int> vector{2, 3, 5};
const std::list<double> list{2.7, 3.14, 1.618};

std::cout << std::right << std::fixed << std::setprecision(3);
std::cout << "Zipped elements:" << std::endl;
for (const auto& elements_tuple : boost::combine(vector, list))
{
    int i;
    double r;
    
    boost::tie(i, r) = elements_tuple;
    std::cout << '(' << std::setw(1) << i << ',' << std::setw(6) << r  << ')' << std::endl;
}