Como chamar apagar com um iterador reverso

Estou tentando fazer algo assim:

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

No entanto, apagar exige um iterador e não um iterador reverso. existe uma maneira de converter um iterador reverso em um iterador regular ou outra maneira de remover esse elemento da lista?

Depois de mais algumas pesquisas e testes, encontrei a solução. Aparentemente, de acordo com o padrão [24.4.1 / 1], a relação entre i.base () ei é:

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

(de um artigo do Dr. Dobbs ):

Portanto, você precisa aplicar um deslocamento ao obter a base (). Portanto, a solução é:

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

EDITAR

Atualizando para C ++ 11.

reverse_iterator ipermanece inalterado:

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

reverse_iterator ié avançado:

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

Acho isso muito mais claro que minha solução anterior. Use o que você precisar.

Observe que m_CursorStack.erase( (++i).base())pode ser um problema se usado em um forloop (consulte a pergunta original), pois altera o valor de i. A expressão correta ém_CursorStack.erase((i+1).base())

... ou outra maneira de remover esse elemento da lista?

Isso requer o -std=c++11sinalizador (para auto):

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

Engraçado que ainda não há uma solução correta nesta página. Portanto, o seguinte é o correto:

No caso do iterador direto, a solução é direta:

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

No caso do iterador reverso, você precisa fazer o mesmo:

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

Notas:

• Você pode construir um reverse_iterator partir de um iterador
• Você pode usar o valor de retorno de std::list::erase

Enquanto estiver usando o reverse_iterator's base()método e diminuindo o resultado funciona aqui, é importante notar que reverse_iterators não é dado o mesmo estatuto que regulares iterators. Em geral, você deve preferir iterators regulares para reverse_iterators (e também para const_iteratores e const_reverse_iterators), por motivos precisos como este. Veja o Diário do Doutor Dobbs para uma discussão aprofundada sobre o porquê.

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

E aqui está o trecho de código para converter o resultado de apagar novamente em um iterador reverso, a fim de apagar um elemento em um contêiner enquanto itera no reverso. Um pouco estranho, mas funciona mesmo ao apagar o primeiro ou o último elemento:

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

Se você não precisar apagar tudo à medida que avança, para resolver o problema, use o idioma apagar-remover:

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

std::removetroca todos os itens no contêiner que correspondem pCursorao final e retorna um iterador para o primeiro item de correspondência. Então oerase uso de um intervalo será apagado da primeira partida e chegará ao fim. A ordem dos elementos não correspondentes é preservada.

Isso pode funcionar mais rápido se você estiver usando um std::vector , onde a exclusão no meio do conteúdo pode envolver muitas cópias ou movimentação.

Ou, é claro, as respostas acima que explicam o uso de reverse_iterator::base()são interessantes e vale a pena conhecer, para resolver o problema exato declarado, eu argumentaria que std::removeé um ajuste melhor.

Só queria esclarecer uma coisa: Em alguns dos comentários e respostas acima, a versão portátil para apagar é mencionada como (++ i) .base (). No entanto, a menos que esteja faltando alguma coisa, a instrução correta é (++ ri) .base (), significando que você 'incrementa' o reverse_iterator (não o iterador).

Encontrei ontem uma necessidade de fazer algo semelhante e este post foi útil. Obrigado a todos.

Para complementar as respostas de outras pessoas e porque eu me deparei com essa pergunta enquanto pesquisava sobre std :: string sem muito sucesso, aqui vai uma resposta com o uso de std :: string, std :: string :: erase e std :: reverse_iterator

Meu problema foi apagar o nome de arquivo de uma imagem de uma string de nome de arquivo completa. Foi originalmente resolvido com std :: string :: find_last_of, mas eu pesquiso uma maneira alternativa com 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\'

Isso usa algoritmos, iteradores e cabeçalhos de string.

O iterador reverso é bastante difícil de usar. Então, apenas usei o iterador geral. 'r' Começa do último elemento. Quando encontrar algo para apagar. apague-o e retorne o próximo iterador. por exemplo, quando excluir o terceiro elemento, ele apontará o quarto elemento atual. e novo terceiro. Portanto, deve ser diminuído 1 para mover para a esquerda

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