remove_if tương đương cho std :: map

Tôi đang cố gắng xóa một loạt các yếu tố khỏi bản đồ dựa trên điều kiện cụ thể. Làm cách nào để thực hiện điều đó bằng thuật toán STL?

Ban đầu tôi nghĩ đến việc sử dụng remove_ifnhưng không thể vì remove_if không hoạt động cho vùng chứa liên kết.

Có bất kỳ thuật toán tương đương "remove_if" nào hoạt động cho bản đồ không?

Như một lựa chọn đơn giản, tôi nghĩ đến việc lặp lại bản đồ và xóa. Nhưng việc lặp lại bản đồ và xóa có phải là một tùy chọn an toàn không? (Vì các trình lặp sẽ không hợp lệ sau khi xóa)

Tôi đã sử dụng ví dụ sau:

bool predicate(const std::pair<int,std::string>& x)
{
    return x.first > 2;
}

int main(void) 
{

    std::map<int, std::string> aMap;

    aMap[2] = "two";
    aMap[3] = "three";
    aMap[4] = "four";
    aMap[5] = "five";
    aMap[6] = "six";

//      does not work, an error
//  std::remove_if(aMap.begin(), aMap.end(), predicate);

    std::map<int, std::string>::iterator iter = aMap.begin();
    std::map<int, std::string>::iterator endIter = aMap.end();

    for(; iter != endIter; ++iter)
    {
            if(Some Condition)
            {
                            // is it safe ?
                aMap.erase(iter++);
            }
    }

    return 0;
}

Hầu hết.

for(; iter != endIter; ) {
     if (Some Condition) {
          iter = aMap.erase(iter);
     } else {
          ++iter;
     }
}

Những gì bạn có ban đầu sẽ tăng trình lặp lên hai lần nếu bạn đã xóa một phần tử khỏi nó; bạn có thể bỏ qua các phần tử cần được xóa.

Đây là một thuật toán phổ biến mà tôi đã thấy được sử dụng và ghi lại ở nhiều nơi.

[EDIT] Bạn nói đúng rằng trình vòng lặp bị vô hiệu sau khi xóa, nhưng chỉ có trình vòng lặp tham chiếu đến phần tử bị xóa, các trình vòng lặp khác vẫn hợp lệ. Do đó sử dụng iter++trong erase()cuộc gọi.

delete_if cho std :: map (và các vùng chứa khác)

Tôi sử dụng mẫu sau cho điều này.

namespace stuff {
  template< typename ContainerT, typename PredicateT >
  void erase_if( ContainerT& items, const PredicateT& predicate ) {
    for( auto it = items.begin(); it != items.end(); ) {
      if( predicate(*it) ) it = items.erase(it);
      else ++it;
    }
  }
}

Thao tác này sẽ không trả lại bất cứ thứ gì, nhưng nó sẽ xóa các mục khỏi bản đồ std ::.

Ví dụ sử dụng:

// 'container' could be a std::map
// 'item_type' is what you might store in your container
using stuff::erase_if;
erase_if(container, []( item_type& item ) {
  return /* insert appropriate test */;
});

Ví dụ thứ hai (cho phép bạn chuyển vào một giá trị thử nghiệm):

// 'test_value' is value that you might inject into your predicate.
// 'property' is just used to provide a stand-in test
using stuff::erase_if;
int test_value = 4;  // or use whatever appropriate type and value
erase_if(container, [&test_value]( item_type& item ) {
  return item.property < test_value;  // or whatever appropriate test
});

Bây giờ, std::experimental::erase_ifcó sẵn trong tiêu đề <experimental/map>.

Xem: http://en.cppreference.com/w/cpp/experimental/map/erase_if

Tôi nhận tài liệu này từ tài liệu tham khảo SGI STL tuyệt vời :

Bản đồ có thuộc tính quan trọng là việc chèn một phần tử mới vào bản đồ không làm mất hiệu lực của các trình vòng lặp trỏ đến các phần tử hiện có. Việc xóa một phần tử khỏi bản đồ cũng không làm mất hiệu lực của bất kỳ trình vòng lặp nào, tất nhiên, ngoại trừ các trình vòng lặp thực sự trỏ đến phần tử đang bị xóa.

Vì vậy, trình lặp mà bạn có đang trỏ đến phần tử cần xóa tất nhiên sẽ bị vô hiệu. Làm điều gì đó như sau:

if (some condition)
{
  iterator here=iter++;
  aMap.erase(here)
}

Mã ban đầu chỉ có một vấn đề:

for(; iter != endIter; ++iter)
{
    if(Some Condition)
    {
        // is it safe ?
        aMap.erase(iter++);
    }
}

Ở đây giá trị iternày được tăng lên một lần trong vòng lặp for và một lần nữa trong quá trình xóa, có thể sẽ kết thúc trong một số vòng lặp vô hạn.

Đây là một số giải pháp thanh lịch.

for (auto it = map.begin(); it != map.end();)
{   
    (SomeCondition) ? map.erase(it++) : (++it);
}

Từ ghi chú cuối cùng của:

http://www.sgi.com/tech/stl/PairAssociativeContainer.html

Một vùng chứa liên kết cặp không thể cung cấp trình vòng lặp có thể thay đổi (như được định nghĩa trong các yêu cầu Trình lặp tầm thường), vì kiểu giá trị của trình lặp có thể thay đổi phải là Có thể gán và cặp không thể Chuyển nhượng được. Tuy nhiên, một Vùng chứa liên kết cặp có thể cung cấp các trình vòng lặp không hoàn toàn không đổi: các trình vòng lặp sao cho biểu thức (* i) .second = d là hợp lệ.

Đầu tiên

Bản đồ có thuộc tính quan trọng là việc chèn một phần tử mới vào bản đồ không làm mất hiệu lực của các trình vòng lặp trỏ đến các phần tử hiện có. Việc xóa một phần tử khỏi bản đồ cũng không làm mất hiệu lực của bất kỳ trình vòng lặp nào, tất nhiên, ngoại trừ các trình vòng lặp thực sự trỏ đến phần tử đang bị xóa.

Thứ hai, mã sau đây là tốt

for(; iter != endIter; )
{
    if(Some Condition)
    {
        aMap.erase(iter++);
    }
    else
    {
        ++iter;
    }
}

Khi gọi một hàm, các tham số được đánh giá trước khi gọi hàm đó.

Vì vậy, khi iter ++ được đánh giá trước khi gọi xóa, toán tử ++ của trình vòng lặp sẽ trả về mục hiện tại và sẽ trỏ đến mục tiếp theo sau cuộc gọi.

IMHO không có remove_if()tương đương.
Bạn không thể sắp xếp lại bản đồ.
Vì vậy, remove_if()không thể đặt các cặp sở thích của bạn ở cuối mà bạn có thể gọi erase().

Dựa trên câu trả lời của Iron Savior Đối với những người muốn cung cấp một phạm vi nhiều hơn dọc theo các dòng của trình vòng lặp lấy chức năng std.

template< typename ContainerT, class FwdIt, class Pr >
void erase_if(ContainerT& items, FwdIt it, FwdIt Last, Pr Pred) {
    for (; it != Last; ) {
        if (Pred(*it)) it = items.erase(it);
        else ++it;
    }
}

Tò mò nếu có cách nào đó để mất các ContainerTmục và lấy nó từ trình lặp.

Câu trả lời của Steve Folly tôi cảm thấy hiệu quả hơn.

Đây là một giải pháp dễ dàng nhưng kém hiệu quả hơn :

Giải pháp sử dụng remove_copy_ifđể sao chép các giá trị mà chúng ta muốn vào một vùng chứa mới, sau đó hoán đổi nội dung của vùng chứa ban đầu với nội dung của vùng chứa mới:

std::map<int, std::string> aMap;

...
//Temporary map to hold the unremoved elements
std::map<int, std::string> aTempMap;

//copy unremoved values from aMap to aTempMap
std::remove_copy_if(aMap.begin(), aMap.end(), 
                    inserter(aTempMap, aTempMap.end()),
                    predicate);

//Swap the contents of aMap and aTempMap
aMap.swap(aTempMap);

Nếu bạn muốn xóa tất cả các phần tử có khóa lớn hơn 2, thì cách tốt nhất là

map.erase(map.upper_bound(2), map.end());

Tuy nhiên, chỉ hoạt động cho phạm vi, không cho bất kỳ vị ngữ nào.

Tôi sử dụng như thế này

 std::map<int, std::string> users;    
 for(auto it = users.begin(); it <= users.end()) {
    if(<condition>){
      it = users.erase(it);
    } else {
    ++it;
    }
 }