反向迭代2个循环？

Question

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

通常我可以做这样的事情：

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

如果您使用的是向前迭代指数为何不反向？即

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

Answer 3

你不需要迭代器（反向或以其他方式）。如果你喜欢的代码，你现在所拥有的，只是希望它的反向运行，你能做到这一点相当直接：

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 4

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

迭代器是更灵活的这种方式比指数为基础的 - 这是简单得多的改变开始/ rbegin，结束/ rend和reverse_iterator/iterator，来改变iterat离子方向。如果你经常使用这个代码，这会变得更加容易，并且只能在某个地方粘贴typedef，如果你有C++ 0x或者可以使用内联函数进行自动类型推演，那么这个代码绝对是最好的。

Answer 5

你也可以使用反向迭代器，但它有点冗长。如果你有升压，但是，它真的很容易，你可以这样做：

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

Answer 6

迭代器容器允许您使用*或访问“当前”对象 - >运营商 - 在这个意义上迭代器像指向矢量元素的指针。

例如，如果iter是一个迭代上的层的载体，然后可以访问当前使用迭代指向的层：

layer = *(iter); 

或

nshapes = iter->shapes.size(); 

Answer 7

使用反向迭代器。

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（）和雷德（）函数：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(); 
    } 
}