Question

基本上我想反向迭代2 std :: vectors。图层有一个形状矢量。

通常我可以这样做：

for(int i = 0; i < layers.size(); ++i)
{
   for(int j = 0; j < layers[i].shapes.size(); ++j)
   {
      layers[i].shapes[j].dosomething();
   }
}

但是现在我需要反向遍历向量，因此需要使用反向迭代器，但这将如何工作？由于迭代器类似于每个迭代器，我如何访问正在迭代的当前层的当前形状？感谢

Answer 1

简单方法：

for(int i = layers.size() - 1; i >= 0; --i)
{
   for(int j = layers[i].shapes.size() - 1; j >= 0; --j)
   {
      layers[i].shapes[j].dosomething();
   }
}

“正确”的方式：

for(vector<Layer>::reverse_iterator i = layers.rbegin(); i != layers.rend(); ++i)
{
   for(vector<Shape>::reverse_iterator j = i->shapes.rbegin(); j != i->shapes.rend(); ++j)
   {
      j->dosomething();
   }
}

Answer 2

使用反向迭代器。

typedef std::vector::<Layer>::reverse_iterator LayerIt;
for(LayerIt layerIt = layers.rbegin(); layerIt != layers.rend(); ++layerIt) // reverse-iterator
{
   Layer& layer = *layerIt;

   typedef std::vector<Shape>::reverse_iterator ShapeIt;
   std::vector<Shape>& shapes = layer.shapes;

   for(ShapeIt shapeIt = shapes.rbegin(); shapeIt != shapes.rend(); ++shapeIt) // reverse-iterator
   {
     Shape& shape = *shapeIt;
     shape.dosomething();
    }
}

参见std :: vector的rbegin（）和rend（）函数：http://www.cplusplus.com/reference/stl/vector/ 我将代码分解为更明显，告诉我它是不是。如果您不了解迭代器，则必须搜索：）

请注意，如果您使用具有新auto功能的最新编译器，则编写起来更简单：

for(auto layerIt = layers.rbegin(); layerIt != layers.rend(); ++layerIt) // reverse-iterator
{
   Layer& layer = *layerIt;
   std::vector<Shape>& shapes = layer.shapes;

   for(auto shapeIt = shapes.rbegin(); shapeIt != shapes.rend(); ++shapeIt) // reverse-iterator
   {
     Shape& shape = *shapeIt;
     shape.dosomething();
    }
}

Answer 3

如果您使用索引进行前向迭代，为什么不进行反向？即

for( int i = layers.size()-1; i>=0; --i )

Answer 4

你真的不需要迭代器（反向或其他）。如果您喜欢现在拥有的代码，并希望它反向运行，您可以直接这样做：

for (int i=layers.size()-1; i>-1; --i)
    for (int j=layers[i].shapes.size()-1; j>-1; --j)
        layers[i].shapes[j].dosomething();

当然，如果您愿意，可以使用迭代器，但在这种情况下，我认为它会使代码更长，更复杂，而不会增加太多：

std::vector<shape>::reverse_iterator this_shape;
std::vector<layer>::reverse_iterator this_layer;

for (this_layer = layers.rbegin(); this_layer != layers.rend(); ++this_layer)
   for (this_shape = this_layer->shapes.rbegin(); this_shape != this_layer->shapes.rend(); ++this_shape)
       this_shape->dosomething();

Answer 5

for(std::vector<mytype>::reverse_iterator i = layers.rbegin(); i != layers.rend(); ++i)
{
   for(std::vector<myothertype>::reverse_iterator j = i->shapes.rbegin(); j != i->shapes.rend(); ++j)
   {
      j->dosomething();
   }
}

迭代器比基于索引的方式更灵活 - 更改begin / rbegin，end / rend和reverse_iterator / iterator以更改迭代方向要简单得多。如果你经常使用这个代码并且可以在某个地方粘贴一个typedef，那就更容易了，如果你有C ++ 0x或者可以使用内联函数进行自动类型演绎，这肯定是最好的。

Answer 6

你也可以使用反向迭代器，但它有点冗长。但是，如果你有Boost，那么你可以做的很简单：

BOOST_REVERSE_FOREACH( std::vector<Shape>& layer, layers )
{
  BOOST_REVERSE_FOREACH( Shape& shape, layer )
  {
    shape.dosomething();
  }
}

Answer 7

迭代器到容器允许您使用*或 - ＆gt;访问“当前”对象运算符 - 在这种意义上，迭代器就像指向向量元素的指针。

例如，如果iter是图层矢量上的迭代器，那么您可以使用以下方法访问迭代器当前指向的图层：

layer = *(iter);

或

nshapes = iter->shapes.size();

用2个循环反向迭代？

7 个答案: