Cách gọi xóa bằng trình lặp ngược

Tôi đang cố gắng làm một cái gì đó như thế này:

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

Tuy nhiên, erase mất một iterator chứ không phải iterator ngược. Có cách nào để chuyển đổi một trình vòng lặp ngược thành một trình vòng lặp thông thường hoặc một cách khác để loại bỏ phần tử này khỏi danh sách?

Sau một số nghiên cứu và thử nghiệm, tôi tìm thấy giải pháp. Rõ ràng theo tiêu chuẩn [24.4.1 / 1] mối quan hệ giữa i.base () và i là:

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

(từ một bài báo của Tiến sĩ Dobbs ):

Vì vậy, bạn cần phải áp dụng một bù khi lấy cơ sở (). Do đó, giải pháp là:

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

BIÊN TẬP

Cập nhật cho C ++ 11.

Reverse_iterator ikhông thay đổi:

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

Reverse_iterator ilà nâng cao:

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

Tôi thấy điều này rõ ràng hơn nhiều so với giải pháp trước đây của tôi. Sử dụng bất cứ điều gì bạn yêu cầu.

Xin lưu ý rằng m_CursorStack.erase( (++i).base())có thể là một vấn đề nếu được sử dụng trong một forvòng lặp (xem câu hỏi ban đầu) vì nó thay đổi giá trị của i. Biểu thức đúng làm_CursorStack.erase((i+1).base())

... Hoặc một cách khác để loại bỏ yếu tố này khỏi danh sách?

Điều này đòi hỏi -std=c++11cờ (cho auto):

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

Thật buồn cười là không có giải pháp chính xác trên trang này. Vì vậy, sau đây là đúng:

Trong trường hợp bộ lặp tiến, giải pháp là thẳng về phía trước:

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

Trong trường hợp lặp lại, bạn cần phải làm như vậy:

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

Ghi chú:

• Bạn có thể xây dựng một reverse_iteratortừ một trình vòng lặp
• Bạn có thể sử dụng giá trị trả về của std::list::erase

Trong khi sử dụng reverse_iterator's base()phương pháp và decrementing kết quả làm việc ở đây, đó là đáng chú ý là reverse_iterators không cho tình trạng giống như thường xuyên iterators. Nói chung, bạn nên thích iterators thường xuyên hơn s reverse_iterator(cũng như const_iterators và const_reverse_iterators), vì những lý do chính xác như thế này. Xem Tạp chí của Bác sĩ Dobbs để thảo luận chuyên sâu về lý do tại sao.

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

Và đây là đoạn mã để chuyển đổi kết quả của việc xóa trở lại một trình vòng lặp ngược để xóa một phần tử trong một thùng chứa trong khi lặp lại theo chiều ngược lại. Hơi lạ một chút, nhưng nó hoạt động ngay cả khi xóa phần tử đầu tiên hoặc cuối cùng:

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

Nếu bạn không cần xóa mọi thứ khi bạn thực hiện, thì để giải quyết vấn đề, bạn có thể sử dụng thành ngữ erase-remove:

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

std::removehoán đổi tất cả các mục trong vùng chứa khớp pCursorđến cuối và trả về một trình vòng lặp cho mục khớp đầu tiên. Sau đó,erase sử dụng một phạm vi sẽ xóa khỏi trận đấu đầu tiên và đi đến kết thúc. Thứ tự của các yếu tố không phù hợp được bảo tồn.

Điều này có thể giải quyết nhanh hơn cho bạn nếu bạn đang sử dụng một std::vector , trong đó việc xóa ở giữa nội dung có thể liên quan đến việc sao chép hoặc di chuyển rất nhiều.

Hoặc tất nhiên, các câu trả lời ở trên giải thích việc sử dụng reverse_iterator::base()rất thú vị và đáng để biết, để giải quyết vấn đề chính xác đã nêu, tôi cho rằng đó std::removelà cách phù hợp hơn.

Chỉ muốn làm rõ điều gì đó: Trong một số ý kiến ​​và câu trả lời ở trên, phiên bản di động để xóa được đề cập là (++ i) .base (). Tuy nhiên, trừ khi tôi thiếu một cái gì đó, câu lệnh đúng là (++ ri) .base (), nghĩa là bạn 'gia tăng' Reverse_iterator (không phải là iterator).

Tôi đã gặp phải một nhu cầu để làm một cái gì đó tương tự ngày hôm qua và bài viết này là hữu ích. Cảm ơn mọi người.

Để bổ sung cho câu trả lời của người khác và vì tôi vấp phải câu hỏi này trong khi tìm kiếm về std :: string mà không có nhiều thành công, đây là câu trả lời với việc sử dụng std :: string, std :: string :: erase và std :: Reverse_iterator

Vấn đề của tôi là xóa tên tệp hình ảnh khỏi chuỗi tên tệp hoàn chỉnh. Ban đầu nó đã được giải quyết với std :: string :: find_last_of, nhưng tôi nghiên cứu một cách khác với 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\'

Điều này sử dụng thuật toán, iterator và tiêu đề chuỗi.

iterator ngược khá khó sử dụng. Vì vậy, chỉ sử dụng lặp chung. 'r' Nó bắt đầu từ yếu tố cuối cùng. Khi tìm thấy một cái gì đó để xóa. xóa nó và trở lại iterator tiếp theo. ví dụ: khi xóa phần tử thứ 3, nó sẽ trỏ phần tử thứ 4 hiện tại. và thứ 3 mới. Vì vậy, nên giảm 1 để di chuyển sang trái

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