Функция Sequence-zip для с ++ 11?

100

С новым циклом for на основе диапазона мы можем писать такой код, как

for(auto x: Y) {}

Какой IMO является огромным улучшением (например)

for(std::vector<int>::iterator x=Y.begin(); x!=Y.end(); ++x) {}

Можно ли использовать его для перебора двух одновременных циклов, например zipфункции Pythons ? Для тех, кто не знаком с 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)

Зацепил
источник
На основе диапазона forможно использовать только одну переменную, поэтому нет. Если вы хотите получить доступ к двум значениям одновременно, вам нужно будет использовать что-то вродеstd::pair
Сет Карнеги
4
@SethCarnegie: не напрямую, но вы могли бы придумать zip()функцию, которая возвращает кортежи и выполняет итерацию по списку кортежей.
Андре Карон
2
@ AndréCaron, вы правы, мое «нет» означало, что вы не можете использовать две переменные, а не то, что вы не можете перебирать два контейнера одновременно.
Сет Карнеги,
Ясно, что for(;;)можно добиться такого поведения, хотя и долгого, так что вопрос в самом деле: возможно ли для «авто» использовать сразу два объекта?
В будущей версии (надеюсь, C ++ 17) капитальный ремонт STL будет включать диапазоны . Тогда view :: zip может предоставить предпочтительное решение.
John McFarlane

Ответы:

89

Предупреждение: boost::zip_iterator и boost::combineначиная с Boost 1.63.0 (26 декабря 2016 г.) вызовет неопределенное поведение, если длина входных контейнеров не одинакова (это может привести к сбою или итерации за пределами конца).


Начиная с Boost 1.56.0 (7 августа 2014 г.) вы можете использовать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 а 4
5 8 б 5
6 9 с 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);
}

Использование такое же.

Kennytm
источник
1
вы могли бы использовать это для сортировки? т.е. std :: sort (zip (a.begin (), ...), zip (a.end (), ...), [] (tup a, tup b) {a.get <0> () > b.get <0> ()}); ?
gnzlbg
@gnzlbg: Нет, не можешь .
kennytm
Я был бы соблазнен optionalэлементами для
бесконечных
3
Есть ли шанс сделать это с помощью std :: make_tuple и std :: tie? Я пытался использовать это, сводя к минимуму зависимость от повышения, но у меня не получалось заставить его работать.
Carneiro
@kennytm есть идеи, почему они решили пойти с UB, а не просто заканчивать в конце самого короткого диапазона в связке?
Catskul 06
18

Так что я написал этот zip раньше, когда мне было скучно, я решил опубликовать его, потому что он отличается от других тем, что не использует ускорение и больше похож на 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());
}
Ааронман
источник
4
Вы должны проверить, находится ли какой-либо из итераторов в конце.
Xeo
1
@Xeo: все диапазоны должны быть того же размера, что и первый, или больше
aaronman
Вы можете объяснить, как [](int i,int j,float k,float l)работает? Это лямбда-функция?
изменен
@Hooked, да, это лямбда, она в основном работает, std::for_eachно вы можете использовать произвольное количество диапазонов, параметры в лямбде зависят от того, сколько итераторов вы даете функции,
aaronman
1
Распространенная потребность состоит в том, чтобы застегнуть диапазоны разного размера или даже с бесконечными диапазонами.
Xeo
18

std :: transform может сделать это тривиально:

std::vector<int> a = {1,2,3,4,5};
std::vector<int> b = {1,2,3,4,5};
std::vector<int>c;
std::transform(a.begin(),a.end(), b.begin(),
               std::back_inserter(c),
               [](const auto& aa, const auto& bb)
               {
                   return aa*bb;
               });
for(auto cc:c)
    std::cout<<cc<<std::endl;

Если вторая последовательность короче, моя реализация, похоже, дает инициализированные значения по умолчанию.

Венки
источник
1
Если вторая последовательность короче, то я ожидал бы, что это UB, поскольку вы будете повторять итерацию с конца b.
Адриан
16

Вы можете использовать решение на основе boost::zip_iterator. Создайте фальшивый контейнерный класс, поддерживающий ссылки на ваши контейнеры, которые возвращаются zip_iteratorиз функций-членов beginи end. Теперь ты можешь писать

for (auto p: zip(c1, c2)) { ... }

Пример реализации (протестируйте):

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

Я оставляю вариативную версию как отличное упражнение для читателя.

Александр С.
источник
3
+1: Boost.Range, вероятно, должен включать это. Фактически, я брошу им запрос на эту функцию.
Никол Болас
2
@NicolBolas: У тебя все хорошо. Это должно быть довольно легко реализовать с помощью boost::iterator_range+ boost::zip_iterator, даже в вариационной версии.
Alexandre C.
1
Я считаю, что это никогда не прекратится (и будет иметь неопределенное поведение), если диапазоны не одинаковой длины.
Джонатан Уэйкли
1
boost::zip_iteratorне работает с диапазонами разной длины
Джонатан Уэйкли
1
Это также должно работать даже в чистом С ++ 03 с парой вместо кортежа. Тем не менее, это также может создать проблемы, когда длины не равны. Что-то можно сделать с end (), взяв соответствующий end () самого маленького контейнера. Кажется, это указано в спецификации, как и в вопросе OP.
Пол
15

См <redi/zip.h>для zipфункции , которая работает с диапазоном базой forи принимает любое количество диапазонов, которые могут быть rvalues или lvalues и может быть разной длиной (итерация остановится в конце самого короткого диапазона).

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

Джонатан Уэйкли
источник
2
вы также можете использовать boost/tuple/tuple_io.hpptocout << i;
kirill_igum
Это то, что у меня сработало. Однако в моем коде мне пришлось использовать эквивалент boost::get<0>(i)и boost::get<1>(i). Я не уверен, почему исходный образец нельзя было адаптировать напрямую, возможно, это связано с тем, что мой код принимает постоянные ссылки на контейнеры.
YitzikC 06
11

С диапазоном-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)]

csguth
источник
@ einpoklum-reinstateMonica теперь она есть!
yuyoyuppe
6

Я столкнулся с этим же вопросом независимо, и мне не понравился синтаксис любого из вышеперечисленных. Итак, у меня есть короткий заголовочный файл, который, по сути, делает то же самое, что и boost zip_iterator, но имеет несколько макросов, чтобы сделать синтаксис более удобным для меня:

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;

Главный синтаксический сахар состоит в том, что я могу давать названия элементам из каждого контейнера. Я также включаю «mapfor», который делает то же самое, но для карт (чтобы назвать «.first» и «.second» элемента).

cshelton
источник
Это здорово! Может ли оно принимать произвольное количество аргументов, ведь все они ограничены вашим умным шаблоном до конечного числа?
Повесить
В настоящее время он обрабатывает до 9 параллельных контейнеров. Это было бы просто продвинуть вперед. Хотя макросы с переменным числом аргументов позволяют одному макросу zipfor обрабатывать разное количество параметров, все равно нужно кодировать отдельный макрос для каждого (для отправки). См. Groups.google.com/forum/?fromgroups=#!topic/comp.std.c/… и stackoverflow.com/questions/15847837/…
cshelton
Хорошо ли он обрабатывает аргументы разного размера? (как описано в ОП)
coyotte508
@ coyotte508, предполагается, что первый контейнер имеет наименьшее количество элементов (и игнорирует лишние элементы в других контейнерах). Было бы легко изменить, чтобы не делать этого предположения, но это замедлит его (в настоящее время это не медленнее, чем написано вручную), когда количество элементов совпадает.
cshelton
6
// declare a, b
BOOST_FOREACH(boost::tie(a, b), boost::combine(list_of_a, list_of_b)){
    // your code here.
}
Кальмар
источник
6

Если вам нравится перегрузка операторов, есть три возможности. Первые два используют std::pair<>и std::tuple<>, соответственно, в качестве итераторов; третий расширяет это до диапазона for. Обратите внимание, что не всем понравятся эти определения операторов, поэтому лучше хранить их в отдельном пространстве имен и иметь 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;
    }
}
лорро
источник
3

Для библиотеки потоковой обработки C ++, которую я пишу, я искал решение, которое не полагается на сторонние библиотеки и работает с произвольным количеством контейнеров. Я пришел к этому решению. Это похоже на принятое решение, которое использует ускорение (а также приводит к неопределенному поведению, если длины контейнеров не равны)

#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)...));
}
туманы
источник
1
ссылка не работает ... было бы полезно, если в сообщении показано, как ее использовать, например, main ()?
javaLover
@javaLover: вы можете использовать его так же, как cppitertools в ответе @ knedlsepp. Одно заметное отличие состоит в том, что с помощью вышеуказанного решения вы не можете изменять базовые контейнеры, поскольку operator*for seq::iteratorвозвращает std::tupleконстантные ссылки.
winnetou
2

Если у вас есть компилятор, совместимый с C ++ 14 (например, gcc5), вы можете использовать zipпредоставленный в cppitertoolsбиблиотеке Ryan Haining, что выглядит действительно многообещающим:

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
}
Knedlsepp
источник
0

Boost.Iterators zip_iteratorможно использовать (примеры в документации). Он не будет работать с диапазоном для, но вы можете использовать std::for_eachи лямбду.

Кошка Плюс Плюс
источник
Почему это не работает с диапазоном для? Объедините его с Boost.Range, и вы должны быть настроены.
Xeo
@Xeo: Я не слишком хорошо знаю Range. Я предполагаю, что вы могли бы задействовать какой-то шаблон и заставить его работать, но использование IMO for_eachбудет меньше хлопот.
Cat Plus Plus
Вы имеете в виду что - то вроде этого не хлопот: std::for_each(make_zip_iterator(make_tuple(Y1.begin(), Y2.begin())), make_zip_iterator(make_tuple(Y1.end(), Y2.end())), [](const tuple<int, int>& t){printf("%d %d\n", get<0>(t), get<1>(t)); });?
UncleBens
2
Я должен начать кампанию " Лямбда не делает std :: for_each полезным". :)
UncleBens
2
@Xeo: Наверное, это должен быть отдельный вопрос, но почему?
UncleBens
-2

Вот простая версия, не требующая буста. Он не будет особенно эффективным, поскольку он создает временные значения и не обобщает контейнеры, кроме списков, но он не имеет зависимостей и решает наиболее распространенный случай архивирования.

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

Хотя другие версии более гибкие, часто смысл использования оператора списка состоит в том, чтобы сделать простой однострочным. Эта версия имеет то преимущество, что общий случай прост.

Андрей
источник