c++ - 如何使用 c++11 语法创建 for 循环以遍历 vector

Question

我有一个 class，其中包含一些 vectors(此处代码最少):

class Foo
{
public: 
   Foo() = default;
private:
   void DoStuff(); 

   std::vector<int>&    mBarInt;
   std::vector<double>  mBarDouble;

   int do_something_with_int;
   double do_something_with_double;
};

在我的 DoStuff() 方法中我有:

void Foo::DoStuff()
{
    for(auto &val : mBarInt)
    {
        // do something here...
        do_something_with_int = val + ....
    }
}

我想做这样的事情，访问同一 for 上的两个 vector ，但是(请参阅下面的代码)...

for(int i = 0 ; i < mBarInt.size() ; i++)
{
    // do something here...
    do_something_with_int = mBarInt[i] + ....
    do_something_with_double = mBarDouble[i] + .... // I know mBarDouble has the same size has mBarInt
}

... 保持与以下相同的 c++11 语法:for(auto &val : mBarInt)

如下所示:

void Foo::DoStuff()
{
    for(auto &val1, auto val2 : mBarInt, mBarDouble) //?????<---- How can I do this?
    {
         // do something with val1 and val2, which I know that will point to different vectors, but on the same index.
    }
}

Answer 1

template<class It>
struct indexing_iterator {
  It it = {};
  using value_type = It;
  using reference = value_type;
  It operator*() const { return it; }
  indexing_iterator& operator++() { ++it; return *this; }
  friend bool operator==( indexing_iterator const& lhs, indexing_iterator const& rhs ) {
    return lhs.it == rhs.it;
  }
  friend bool operator!=( indexing_iterator const& lhs, indexing_iterator const& rhs ) {
    return !(lhs==rhs);
  }
};

template<class F, class It_in>
struct transform_iterator_t:indexing_iterator<It_in> {
  F f = {};
  using reference = decltype(std::declval<F&>()( *std::declval<It_in&>() ) );
  using value_type = std::decay_t<reference>;
  using pointer = value_type*;

  reference operator*() { return f(*this->it); }
  transform_iterator_t( F f_in, It_in it_in ):
    indexing_iterator<It_in>{it_in},
    f(f_in)
  {}
};
template<class F, class It_in>
transform_iterator_t<F,It_in> transform_iterator(
  F f, It_in it
) {
  return {f, it};
}

indexing_iterator<std::size_t> index( std::size_t n ) {
  return {n};
}

template<class It>
struct range_t {
  It b,e;
  It begin() const { return b; }
  It end() const { return b; }
};
template<class It>
range_t<It> range( It b, It e ) { return {b,e}; }

auto range_upto( std::size_t n ) {
  return range( index(0), index(n) );
}

template<class C>
auto to_range( C&& c ) {
  using std::begin; using std::end;
  return range( begin(c), end(c) );
}

template<class It, class F>
range_t< transform_iterator< F, It > >
transform_range( F f, range_t<It> range ) {
  return {
    transform_iterator( f, range.begin() ),
    transform_iterator( f, range.end() )
  };
}

template<class F>
auto generator_range( F f, std::size_t count ) {
  return transform_range( f, range_upto(count) );
}

template<class C1, class C2>
auto zip_over( C1& c1, C2& c2 ) {
  return generator_range(
    [&](std::size_t i) {
      return std::tie( c1[i], c2[i] );
    },
    (std::min)(c1.size(), c2.size())
  );
}

然后在 C++17 中我们有

void Foo::DoStuff() {
  for(auto&&[val1, val2] : zip_over(mBarInt, mBarDouble)) {
  }
}

或者您可以在 C++14 中手动解压元组。

看起来工作量很大。

boost里面有zip之类的实现和其他库，包括 Rangev3。

代码未经测试。设计应该是合理的。

可能有更短的方法可以更直接地做到这一点，但我发现通过转换和索引生成器，通过生成器压缩，更容易理解和编写，错误更少。

安indexing_iterator获取一个可递增的可比较对象，并对其进行迭代。 It可以是类整数或交互符。

A transform_iterator采用迭代器和转换，并返回每个元素的转换。

全迭代器都不是；我跳过了样板。但它们足够 for(:)循环。

A range持有 2 个迭代器并将它们公开给 for(:) .

安indexing_iterator<std::size_t>也称为计数迭代器。

生成器迭代器是计数迭代器的一种转换。它接受一个接受索引的函数，并为该索引生成一个元素。

我们通过生成调用 operator[] 的生成器迭代器来压缩两个随机访问容器在两者上，然后返回一个元组。更高级的压缩处理非随机访问容器。

然后，两个容器的 zip 允许您在两个不同的容器上并行迭代。

然后我在 for(:) 中使用 C++17 结构化绑定(bind)语句将它们解包为两个不同的变量。我们可以改为手动解包作为 for 循环中的前 2 条语句。