如何使用反向迭代器调用擦除

我正在尝试做这样的事情：

for ( std::list< Cursor::Enum >::reverse_iterator i = m_CursorStack.rbegin(); i != m_CursorStack.rend(); ++i )
{
    if ( *i == pCursor )
    {
        m_CursorStack.erase( i );
        break;
    }
}

但是，擦除需要迭代器，而不是反向迭代器。有没有一种方法可以将反向迭代器转换为常规迭代器，或从列表中删除此元素的另一种方法？

经过更多的研究和测试，我找到了解决方案。显然，根据标准[24.4.1 / 1]，i.base（）和i之间的关系为：

&*(reverse_iterator(i)) == &*(i - 1)

（摘自Dobbs博士的文章）：

因此，在获取base（）时需要应用偏移量。因此，解决方案是：

m_CursorStack.erase( --(i.base()) );

编辑

为C ++ 11更新。

reverse_iterator i保持不变：

m_CursorStack.erase( std::next(i).base() );

reverse_iterator i是高级的：

std::advance(i, 1);
m_CursorStack.erase( i.base() );

我发现这比我以前的解决方案要清楚得多。使用任何您需要的。

请注意，m_CursorStack.erase( (++i).base())如果在for循环中使用（请参阅原始问题）可能会出现问题，因为它会更改i的值。正确的表达是m_CursorStack.erase((i+1).base())

...或从列表中删除此元素的另一种方法？

这需要-std=c++11标记（用于auto）：

auto it=vt.end();
while (it>vt.begin())
{
    it--;
    if (*it == pCursor) //{ delete *it;
        it = vt.erase(it); //}
}

有趣的是，此页面上尚无正确的解决方案。因此，以下是正确的方法：

如果使用正向迭代器，则解决方案很简单：

std::list< int >::iterator i = myList.begin();
while ( ; i != myList.end(); ) {
  if ( *i == to_delete ) {
    i = myList.erase( i );
  } else {
    ++i;
  } 
}

对于反向迭代器，您需要执行以下操作：

std::list< int >::reverse_iterator i = myList.rbegin();
while ( ; i != myList.rend(); ) {
  if ( *i == to_delete ) {
    i = decltype(i)(myList.erase( std::next(i).base() ));
  } else {
    ++i;
  } 
}

笔记：

• 您可以构造一个 reverse_iterator从迭代器
• 您可以使用的返回值 std::list::erase

在使用 reverse_iterator的base()方法并递减结果在这里有效，但值得注意的是，reverse_iterators的状态与常规iterators的状态不同。通常，出于这样的确切原因，您应该更喜欢Regular iterators reverse_iterator（以及const_iterators和const_reverse_iterators）。有关原因的详细讨论，请参见《多布斯医生杂志》。

typedef std::map<size_t, some_class*> TMap;
TMap Map;
.......

for( TMap::const_reverse_iterator It = Map.rbegin(), end = Map.rend(); It != end; It++ )
{
    TMap::const_iterator Obsolete = It.base();   // conversion into const_iterator
    It++;
    Map.erase( Obsolete );
    It--;
}

这是一段代码，用于将擦除结果转换回反向迭代器，以便在反向迭代时擦除容器中的元素。有点奇怪，但是即使删除第一个或最后一个元素，它也可以工作：

std::set<int> set{1,2,3,4,5};

for (auto itr = set.rbegin(); itr != set.rend(); )
{    
    if (*itr == 3)
    {
        auto it = set.erase(--itr.base());
        itr = std::reverse_iterator(it);            
    }
    else
        ++itr;
}

如果您不需要一路擦除所有内容，那么要解决此问题，可以使用“擦除删除”惯用语：

m_CursorStack.erase(std::remove(m_CursorStack.begin(), m_CursorStack.end(), pCursor), m_CursorStack.end());

std::remove交换容器中所有匹配pCursor到末尾的项目，并将迭代器返回到第一个匹配项。然后，erase使用范围将从第一个匹配项中删除，然后结束。不匹配元素的顺序得以保留。

如果您使用的是 std::vector，，其中内容的中间擦除可能涉及大量复制或移动。

或者，以上解释使用的答案当然reverse_iterator::base()很有趣，并且值得了解，为了解决上述确切问题，我认为这std::remove是一个更好的选择。

只是想澄清一下：在上面的某些评论和答案中，用于擦除的可移植版本称为（++ i）.base（）。但是，除非我缺少某些内容，否则正确的语句是（++ ri）.base（），这意味着您将“递增” reverse_iterator（而不是迭代器）。

昨天我遇到了需要做类似事情的需要，这篇文章很有帮助。感谢大家。

为了补充其他人的答案，并且由于我在搜索std :: string时无意中发现了这个问题，因此没有太大的成功，下面是使用std :: string，std :: string :: erase和std :: reverse_iterator的响应

我的问题是从完整的文件名字符串中删除图像文件名。它最初是用std :: string :: find_last_of解决的，但是我研究了std :: reverse_iterator的另一种方法。

std::string haystack("\\\\UNC\\complete\\file\\path.exe");
auto&& it = std::find_if( std::rbegin(haystack), std::rend(haystack), []( char ch){ return ch == '\\'; } );
auto&& it2 = std::string::iterator( std::begin( haystack ) + std::distance(it, std::rend(haystack)) );
haystack.erase(it2, std::end(haystack));
std::cout << haystack;  ////// prints: '\\UNC\complete\file\'

这使用算法，迭代器和字符串头。

反向迭代器很难使用。因此，只使用了通用迭代器。'r'从最后一个元素开始。当发现要擦除的东西时。擦除它并返回下一个迭代器。例如，当删除第三个元素时，它将指向当前的第四个元素。和新的第三。所以应该减少1向左移动

void remchar(string& s,char c)
{      
    auto r = s.end() - 1;
    while (r >= s.begin() && *r == c)
    {
        r = s.erase(r);
        r -= 1;
    }
}