delete_if еквівалент std :: map

Я намагався стерти з карти різноманітні елементи, залежно від конкретних умов. Як це зробити за допомогою алгоритмів STL?

Спочатку я думав використовувати, remove_ifале це неможливо, оскільки Remove_if не працює для асоціативного контейнера.

Чи існує якийсь еквівалентний алгоритм "remove_if", який працює для карти?

Як простий варіант, я подумав прокрутити карту і видалити. Але чи переглядає карту і стирає безпечний варіант? (Як ітератори стають недійсними після стирання)

Я використовував наступний приклад:

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

Майже.

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

Те, що ви мали спочатку, збільшило б ітератор двічі, якщо ви стерли з нього елемент; ви могли потенційно пропустити елементи, які потрібно було стерти.

Це звичайний алгоритм, який я бачив у багатьох місцях, який використовував і документував.

[EDIT] Ви праві, що ітератори недійсні після стирання, але лише ітератори, на які посилається стираний елемент, інші ітератори залишаються дійсними. Отже, використання iter++в erase()дзвінку.

erase_if для std :: карта (та інші контейнери)

Я використовую наступний шаблон для цієї речі.

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

Це нічого не поверне, але вилучить елементи з std :: map.

Приклад використання:

// '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 */;
});

Другий приклад (дозволяє передати тестове значення):

// '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
});

Тепер, std::experimental::erase_ifдоступний у заголовку <experimental/map>.

Дивіться: http://en.cppreference.com/w/cpp/experimental/map/erase_if

Цю документацію я отримав із чудової довідки SGI STL :

Карта має важливе властивість, що вставлення нового елемента в карту не приводить до недійсності ітераторів, які вказують на існуючі елементи. Видалення елемента з карти також не приводить до недійсності будь-яких ітераторів, за винятком, звичайно, ітераторів, які фактично вказують на стирається елемент.

Отже, ітератор, який у вас вказує на стираний елемент, звичайно, буде визнаний недійсним. Зробіть щось подібне:

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

У вихідному коді є лише одне питання:

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

Тут iterінтенсифікується один раз у циклі for та інший раз у стиранні, що, ймовірно, закінчиться в нескінченному циклі.

Ось якесь елегантне рішення.

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

З нижньої замітки:

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

Контейнер для асоційованої пари не може надати змінних ітераторів (як визначено в вимогах Trivial Iterator), оскільки тип значення мутаційного ітератора повинен бути Assignable, а пара не Assignnable. Однак контейнер для асоційованої пари може надавати ітератори, які не є абсолютно постійними: ітератори, такі, що вираз (* i) .second = d є дійсним.

Перший

Карта має важливе властивість, що вставлення нового елемента в карту не приводить до недійсності ітераторів, які вказують на існуючі елементи. Видалення елемента з карти також не приводить до недійсності будь-яких ітераторів, за винятком, звичайно, ітераторів, які фактично вказують на стирається елемент.

По-друге, хороший наступний код

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

Під час виклику функції параметри оцінюються перед викликом до цієї функції.

Отже, коли ітера ++ оцінюється перед видаленням дзвінка, оператор ++ ітератора поверне поточний елемент і вкаже на наступний елемент після виклику.

ІМХО немає remove_if()еквівалента.
Ви не можете впорядкувати карту.
Тож remove_if()не можна ставити свої пари інтересів у кінці, на які можна дзвонити erase().

Виходячи з відповіді Iron Saviour Для тих, хто хотів би надати діапазон більше за напрямками 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;
    }
}

Цікаво, якщо є якийсь спосіб втратити ContainerTелементи і отримати це від ітератора.

Відповідь Стіва Фоллі я вважаю себе більш ефективною.

Ось ще одне просте, але менш ефективне рішення :

Рішення використовує remove_copy_ifдля копіювання потрібних нам значень у новий контейнер, а потім змінює вміст вихідного контейнера на значення нового:

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

Якщо ви хочете стерти всі елементи з клавішею більше 2, то найкращий спосіб

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

Працює лише для діапазонів, але не для будь-якого предиката.

Я використовую так

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