Ters yineleyici ile silme nasıl çağrılır

Ben böyle bir şey yapmaya çalışıyorum:

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

Ancak silme ters yineleyici değil yineleyici alır. bir ters yineleyiciyi normal bir yineleyiciye dönüştürmenin veya bu öğeyi listeden kaldırmanın başka bir yolu var mı?

Biraz daha araştırma ve test yaptıktan sonra çözümü buldum. Görünüşe göre [24.4.1 / 1] standardına göre i.base () ve i arasındaki ilişki:

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

( Dr.Dobbs makalesinden ):

Bu yüzden base () öğesini alırken bir ofset uygulamanız gerekir. Bu nedenle çözüm:

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

DÜZENLE

C ++ 11 için güncelleme.

reverse_iterator ideğişmedi:

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

reverse_iterator igelişmiş:

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

Bunu önceki çözümümden çok daha net buluyorum. İstediğinizi kullanın.

m_CursorStack.erase( (++i).base())Bir fordöngüde kullanılırsa (orijinal soruya bakın) bir sorun olabileceğini lütfen unutmayın, çünkü i değerini değiştirir. Doğru ifade:m_CursorStack.erase((i+1).base())

... veya bu öğeyi listeden çıkarmanın başka bir yolu var mı?

Bu, -std=c++11(için auto) bayrağını gerektirir :

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

Bu sayfada henüz doğru bir çözüm bulunmadığı komik. Yani, aşağıdakiler doğrudur:

İleri yineleyici durumunda, çözüm doğrudan ileri:

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

Ters yineleyici durumunda aynı şeyi yapmanız gerekir:

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

Notlar:

• Bir reverse_iterator bir İlerleticiden
• Dönüş değerini kullanabilirsiniz std::list::erase

reverse_iterator'S base()yöntemini kullanırken ve sonucu azaltmak burada çalışırken , reverse_iterators'nin normal iterators ile aynı statüye sahip olmadığına dikkat etmek önemlidir . Genel olarak, bunun gibi nedenlerden ötürü düzenli iterators'yi reverse_iterators'ye (ayrıca const_iterators ve const_reverse_iterators'ye) tercih etmelisiniz . Nedenini derinlemesine tartışmak için Doktor Dobbs Dergisi'ne bakınız .

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

Ve burada, tersine yineleme yaparken bir kaptaki bir öğeyi silmek için silme sonucunu ters bir yineleyiciye dönüştüren kod parçası. Biraz garip, ancak ilk veya son öğeyi silerken bile çalışır:

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

İlerlerken her şeyi silmeniz gerekmiyorsa, sorunu çözmek için silme-kaldırma deyimini kullanabilirsiniz:

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

std::removekaptaki pCursorsonuna kadar eşleşen tüm öğeleri değiştirir ve ilk eşleme öğesine bir yineleyici döndürür. Ardından, erasebir aralık kullanıldığında ilk eşleşme silinir ve sonuna kadar gider. Eşleşmeyen öğelerin sırası korunur.

Bu, sizin için daha hızlı sonuç verebilir. std::vectorİçeriğin ortasındaki silme işleminin çok fazla kopyalama veya taşıma gerektirebileceği bir , verebilir.

Ya da tabii ki, yukarıdaki kullanımı açıklayan cevaplar reverse_iterator::base()ilginç ve bilmeye değer, belirtilen kesin sorunu çözmek için std::remove, bunun daha uygun olduğunu iddia ediyorum .

Sadece bir şeyi açıklığa kavuşturmak istedim: Yukarıdaki yorumların ve cevapların bazılarında silme için taşınabilir sürüm (++ i) .base () olarak adlandırılır. Ancak bir şey eksik sürece doğru ifade (++ ri) .base (), yani 'ters' yineleyici (yineleyici) 'anlamına gelir.

Dün benzer bir şey yapmaya ihtiyacım vardı ve bu yazı yardımcı oldu. Herkese teşekkürler.

Başkalarının cevaplarını tamamlamak için ve std :: string hakkında çok başarılı olmadan arama yaparken bu soruya tökezlediğim için, burada std :: string, std :: string :: erase ve std :: reverse_iterator kullanımı ile bir yanıt gidiyor

Benim sorunum tam bir dosya adı dizesinden bir görüntü dosya adını silmek oldu. Başlangıçta std :: string :: find_last_of ile çözüldü, ancak std :: reverse_iterator ile alternatif bir yol araştırıyorum.

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\'

Bu algoritma, yineleyici ve dize üstbilgilerini kullanır.

ters yineleyiciyi kullanmak oldukça zordur. Yani sadece kullanılan genel yineleyici. 'r' Son elemandan başlar. Silmek için bir şey bulduğunuzda. silin ve sonraki yineleyiciye dönün. örneğin 3. elemanı sildiğinizde mevcut 4. elemanı gösterecektir. ve yeni 3. Sola gitmek için 1 azaltılmalı

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