Как вызвать стирание с обратным итератором

Я пытаюсь сделать что-то вроде этого:

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)

(из статьи доктора Доббса ):

Поэтому вам нужно применить смещение при получении base (). Поэтому решение:

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

РЕДАКТИРОВАТЬ

Обновление для C ++ 11.

reverse_iterator iне изменяется:

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

обратный_тератор 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. В общем, вы должны предпочесть обычные iterators reverse_iterators (а также 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 () означает, что вы «увеличиваете» обратный итератор (а не итератор).

Я столкнулся с необходимостью сделать что-то подобное вчера, и этот пост был полезен. Спасибо всем.

Чтобы дополнить ответы других и потому что я наткнулся на этот вопрос во время поиска 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' Это начинается с последнего элемента. Когда найдешь что стереть. сотри его и верни следующий итератор. например, при удалении 3-го элемента он будет указывать текущий 4-й элемент. и новый 3-й. Таким образом, это должно быть уменьшено на 1, чтобы двигаться влево

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