Cómo llamar a borrar con un iterador inverso

Estoy tratando de hacer algo como esto:

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

Sin embargo, borrar toma un iterador y no un iterador inverso. ¿Hay alguna forma de convertir un iterador inverso en un iterador regular u otra forma de eliminar este elemento de la lista?

Después de más investigación y pruebas encontré la solución. Aparentemente de acuerdo con el estándar [24.4.1 / 1] la relación entre i.base () e i es:

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

(de un artículo del Dr. Dobbs ):

Por lo tanto, debe aplicar un desplazamiento al obtener la base (). Por lo tanto, la solución es:

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

EDITAR

Actualización para C ++ 11.

reverse_iterator no iha cambiado:

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

reverse_iterator ies avanzado:

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

Esto me parece mucho más claro que mi solución anterior. Use lo que necesite.

Tenga en cuenta que m_CursorStack.erase( (++i).base())puede ser un problema si se usa en un forbucle (consulte la pregunta original) porque cambia el valor de i. La expresión correcta esm_CursorStack.erase((i+1).base())

... u otra forma de eliminar este elemento de la lista?

Esto requiere la -std=c++11bandera (para auto):

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

Es curioso que todavía no haya una solución correcta en esta página. Entonces, el siguiente es el correcto:

En el caso del iterador directo, la solución es sencilla:

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

En caso de iterador inverso, debe hacer lo mismo:

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:

• Puedes construir un reverse_iteratordesde un iterador
• Puede usar el valor de retorno de std::list::erase

Si bien usar el método reverse_iterator's base()y decrementar el resultado funciona aquí, vale la pena señalar que reverse_iteratorno se les da el mismo estado que los iterators normales . En general, debe preferir los iterators a reverse_iterators regulares (así como a const_iterators y const_reverse_iterators), precisamente por razones como esta. Vea el Diario del Doctor Dobbs para una discusión en profundidad de por qué.

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

Y aquí está el fragmento de código para convertir el resultado de borrar de nuevo a un iterador inverso para borrar un elemento en un contenedor mientras se itera en el reverso. Un poco extraño, pero funciona incluso al borrar el primer o el ú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;
}

Si no necesita borrar todo a medida que avanza, para resolver el problema, puede usar el idioma borrar-eliminar:

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

std::removeintercambia todos los elementos en el contenedor que coinciden pCursorhasta el final y devuelve un iterador al primer elemento coincidente. Luego, el eraseuso de un rango se borrará de la primera partida e irá al final. Se conserva el orden de los elementos que no coinciden.

Esto podría funcionar más rápido si está utilizando un std::vector, donde borrar en medio del contenido puede implicar muchas copias o movimientos.

O, por supuesto, las respuestas anteriores que explican el uso de reverse_iterator::base()son interesantes y vale la pena saber, para resolver el problema exacto enunciado, diría que std::removeencaja mejor.

Solo quería aclarar algo: en algunos de los comentarios y respuestas anteriores, la versión portátil para borrar se menciona como (++ i) .base (). Sin embargo, a menos que me falte algo, la declaración correcta es (++ ri) .base (), lo que significa que 'incrementa' el reverse_iterator (no el iterador).

Me encontré con la necesidad de hacer algo similar ayer y esta publicación fue útil. Gracias a todos.

Para complementar las respuestas de otros y debido a que me topé con esta pregunta mientras buscaba sobre std :: string sin mucho éxito, aquí va una respuesta con el uso de std :: string, std :: string :: erase y std :: reverse_iterator

Mi problema fue borrar el nombre de archivo de una imagen de una cadena de nombre de archivo completa. Originalmente se resolvió con std :: string :: find_last_of, pero investigo una forma alternativa con 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\'

Esto utiliza algoritmos, iteradores y encabezados de cadena.

El iterador inverso es bastante difícil de usar. Así que solo usé el iterador general. 'r' Comienza desde el último elemento. Cuando encuentre algo para borrar. bórrelo y vuelva al siguiente iterador. Por ejemplo, cuando elimine el tercer elemento, señalará el cuarto elemento actual. y nuevo 3er. Por lo tanto, debe reducirse 1 para moverse a la izquierda

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