如何在循环中构造带有增量的 std::list 迭代器

Question

我正在尝试对 std::list 进行双循环以对每对元素进行操作。但是，我在初始化第二个迭代器时遇到一些问题。我想写的代码是：

for(std::list<int>::iterator i = l.begin(); i != l.end(); ++i) {
    for(std::list<int>::iterator j = i+1; j != l.end(); ++j) {
        ...
    }
}

这不起作用，因为列表迭代器不是随机访问的，所以你不能做+1。但我在寻找一个简洁的替代方案时遇到了一些麻烦；编译器似乎对 std::list::iterator j(i)++; 不太满意，我对此抱有一些希望。实现我想要的似乎我将不得不有一些尴尬的额外增量，这不能很好地适应 for 循环的结构。

有明显的替代方案（例如使用向量！），但在我看来，应该有一些相当简洁的方法来做到这一点，但我目前还没有看到。

预先感谢您的帮助:)

Answer 1

for(std::list<int>::iterator i = l.begin(); i != l.end(); ++i) {
    std::list<int>::iterator j = i;
    for(std::advance(j, 1); j != l.end(); ++j) {
        ...
    }
}

Answer 2

怎么样：

for (std::list<int>::iterator i = l.begin(); i != l.end(); ++i) {
    for (std::list<int>::iterator j = i; ++j != l.end(); ) {
        // ...
    }
}

Answer 3

for(std::list<int>::iterator i = l.begin(); i != l.end(); ++i) {
    std::list<int>::iterator j = i; ++j;
    for(; j != l.end(); ++j) {
        ...
    }
}

回到游戏中！

实际上，这是数值算法中非常常见的习惯用法，所以我不认为它丑陋。

Answer 4

我只是放弃了我在德克金特利的回答中的想法：

template <typename Iter, typename Dist>
Iter advance_copy(Iter pIter, const Dist& pOffset)
{
    std::advance(pIter, pOffset);

    return pIter;
}

// ...

typedef std::list<int> int_list;

for(int_list::iterator i = l.begin(); i != l.end(); ++i)
{
    for(int_list::iterator j = advance_copy(i, 1); j != l.end(); ++j)
    {
    }
}

你也可以制作另一类实用函数，以帮助使其简洁：

// for consistency,
template <typename Iter>
void increment(Iter& pIter)
{
    ++pIter;
}

template <typename Iter>
Iter increment_copy(Iter pIter)
{
    return ++pIter;
}

// ...

typedef std::list<int> int_list;

for(int_list::iterator i = l.begin(); i != l.end(); ++i)
{
    for(int_list::iterator j = increment_copy(i); j != l.end(); ++j)
    {
    }
}

Answer 5

简单的“简洁”替代方案可以基于以下事实：列表迭代器是具有重载运算符的用户定义类型的对象（而不是内置类型）。 （当然，这并没有正式保证，但是根据列表容器的性质，人们可以预期这一点。）因此，可以将重载的前缀 ++ 运算符应用于临时列表迭代器类型的对象。

要实现您想要的效果，您只需创建 i 的临时副本，使用前缀 ++ 递增它，然后使用结果值初始化 j< /code>

for(std::list<int>::iterator i = l.begin(); i != l.end(); ++i) { 
  for(std::list<int>::iterator j = ++std::list<int>::iterator(i); j != l.end(); ++j) { 
    ... 
  } 
} 

就是这样。请注意，这个技巧相当流行，并且在实际代码中有时会遇到。另请注意，它通常不适用于 std::vector，因为许多实现使用普通内置指针作为向量迭代器，但它通常可以与 std::list 一起使用>。

然而，就我个人而言，我不会在我的代码中真正使用它。您已经收到了几个很好的答案，它们通过添加额外的代码行来实现此目的。

Answer 6

我会采纳肖恩的建议，除了让它成为一个 while 循环：

for (std::list<int>::iterator i = l.begin(); i != l.end(); ++i) {
    std::list<int>::iterator j( i ); 
    while( ++j != l.end() ) {
        // ...
    }
}

Answer 7

如果您已经在使用 Boost，那么最简单的方法是使用 boost::next。

for(std::list<int>::iterator i = l.begin(); i != l.end(); ++i)
    for(std::list<int>::iterator j = boost::next(i); j != l.end(); ++j)