反向迭代向量

Question

我需要从末尾到开头迭代一个向量。 “正确”的方法是

for(std::vector<SomeT>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit)
{
    //do Something
}

当 //do Something 涉及到知道实际索引时，则需要使用 rit 进行一些计算才能获得它，例如 index = v.size() - 1 - (rit - v.rbegin)

如果无论如何都需要索引，那么我坚信最好使用该索引进行迭代

for(int i = v.size() - 1; i >= 0; --i)
{
    //do something with v[i] and i; 
}

这会发出警告：i 是有符号的，而 v.size() 是无符号的。 更改为

for(unsigned i = v.size() - 1; i >= 0; --i) 在功能上是错误的，因为这本质上是一个无限循环 :)< /code>

什么是一种美观的好方法来做我想做的事情，这

• 是无警告的，
• 不涉及强制转换
• ，也不是过于冗长

Answer 1

正如您所注意到的，当无符号时，i >= 0 条件的问题在于该条件始终为真。不要在初始化 i 时减去 1，然后在每次迭代后再次减去 1，而是在检查循环条件后减去 1：

for (unsigned i = v.size(); i-- > 0; )

我喜欢这种样式有几个原因：

• 虽然 i 会环绕到循环结束时的UINT_MAX，它不依赖这种行为——如果类型被签名，它的工作原理是一样的。依赖未签名的环绕对我来说感觉有点像黑客。
• 它只调用 size() 一次。
• 它不使用 >=。每当我在 for 循环中看到该运算符时，我都必须重新读取它以确保不存在相差一错误。
• 如果更改条件中的间距，则可以使其使用 “转到”运算符。

Answer 2

没有什么可以阻止您的 reverse_iterator 循环也使用索引，如多个其他答案中所述。这样，您就可以根据需要在 // do the work 部分中使用迭代器或索引，以最小的额外成本。

size_t index = v.size() - 1;
for(std::vector<SomeT>::reverse_iterator rit = v.rbegin(); 
    rit != v.rend(); ++rit, --index)
{
  // do the work
}

虽然我很想知道你需要索引做什么。访问v[index]与访问*rit相同。

Answer 3

美观！ ;)

for(unsigned i = v.size() - 1; v.size() > i; --i)

Answer 4

在 C++20 中，可以使用范围 (#include )，

//DATA
std::vector<int> vecOfInts = { 2,4,6,8 };

//REVERSE VECTOR 
for (int i : vecOfInts | std::views::reverse)
{
     std::cout << i << "  ";
} 

或者如果需要保存在不同的变量中。

//SAVE IN ANOTHER VARIABLE
auto reverseVecOfInts = std::views::reverse(vecOfInts);

//ITERATION
for (int i : reverseVecOfInts)
{
    std::cout << i << "  ";
}

Answer 5

我更喜欢反向迭代器变体，因为它仍然很容易解释并且可以避免与索引相关的错误。

有时您可以简单地使用 BOOST_REVERSE_FOREACH，这将使您的代码请看以下方式：

reverse_foreach (int value, vector) {
   do_something_with_the_value;
}

---

实际上，您始终可以对此类循环使用 foreach 语句，但随后它们会变得有点不明显：

size_t i = 0;

foreach (int value, vector) {
   do_something;
   ++i;
}

Answer 6

尝试一下：

std::vector<Type> v;
// Some code 
if(v.size() > 0)
{
    unsigned int i = v.size() - 1;
    do
    {
        // Your stuff
    }
    while(i-- > 0);
}

Answer 7

嗨，我认为更好的方法是使用迭代器，就像在第一个示例中使用的那样，如果您需要获取迭代器索引，则可以使用
std::distance 来计算它，如果我理解你的问题

Answer 8

循环条件 i != std::numeric_limits::max() ...或者使用 UINT_MAX 如果您认为它很冗长。
或另一种方式：
for(unsigned j=0, end=v.size(), i=end-1; j
或
for(unsigned end=v.size(), i=end-1; (end-i)

Answer 9

如果你的向量不是很大，你可以将大小转换为 int

for (int i = int(v.size()) - 1; i >= 0; --i) {
    //do something with v[i] and i; 
}

Answer 10

我认为：

for(unsigned i = v.size() - 1; i >= 0; --i)

如果你早点检查就好了

!v.empty()

。

Answer 11

for (it = v.end()-1; it != v.begin()-1; --it)
{
}

“转到”运算符肯定会扰乱我的头。