std :: map için remove_if eşdeğeri

Belirli bir duruma göre haritadan bir dizi öğeyi silmeye çalışıyordum. STL algoritmalarını kullanarak bunu nasıl yaparım?

Başlangıçta kullanmayı düşündüm remove_ifama bu mümkün değil, çünkü remove_if ilişkisel kapsayıcı için çalışmıyor.

Harita için çalışan herhangi bir "remove_if" eşdeğeri algoritması var mı?

Basit bir seçenek olarak, haritayı dolaşıp silmeyi düşündüm. Ancak haritada döngü yapmak ve güvenli bir seçeneği silmek mi? (Silindikten sonra yineleyiciler geçersiz hale geldikçe)

Aşağıdaki örneği kullandım:

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

Neredeyse.

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

Eğer ondan bir eleman silseydiniz, orijinalde yineleyiciyi iki kez artıracaktı ; silinmesi gereken öğeleri potansiyel olarak atlayabilirsiniz.

Bu, birçok yerde kullanıldığını ve belgelendiğini gördüğüm yaygın bir algoritmadır.

[DÜZENLE] Yinelemelerin bir silme işleminden sonra geçersiz kılındığı konusunda haklısınız, ancak yalnızca silinen öğeye başvuran yineleyiciler, diğer yineleyiciler hala geçerli. Dolayısıyla kullanarak iter++içinde erase()çağrı.

std :: map (ve diğer kapsayıcılar) için erase_if

Bunun için aşağıdaki şablonu kullanıyorum.

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

Bu hiçbir şey döndürmez, ancak öğeleri std :: map'den kaldırır.

Kullanım örneği:

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

İkinci örnek (bir test değerini geçmenize izin verir):

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

Şimdi std::experimental::erase_ifbaşlıkta mevcuttur <experimental/map>.

Bakınız: http://en.cppreference.com/w/cpp/experimental/map/erase_if

Bu dokümantasyonu mükemmel SGI STL referansından aldım :

Harita, haritaya yeni bir öğe eklemenin mevcut öğeleri gösteren yineleyicileri geçersiz kılmaması gibi önemli bir özelliğe sahiptir. Bir öğenin haritadan silinmesi, elbette silinen öğeye gerçekten işaret eden yineleyiciler dışında hiçbir yineleyiciyi geçersiz kılmaz.

Dolayısıyla, silinecek öğeye işaret eden sahip olduğunuz yineleyici elbette geçersiz kılınacaktır. Bunun gibi bir şey yapın:

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

Orijinal kodun yalnızca bir sorunu vardır:

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

Burada, iterbir kez for döngüsünde ve başka bir silme işleminde artırılır, bu muhtemelen sonsuz bir döngüde sona erecektir.

İşte bazı zarif çözüm.

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

Alt notlardan:

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

Bir Çift İlişkilendirilebilir Konteyner, değiştirilebilir yineleyiciler sağlayamaz (Trivial Yineleyici gereksinimlerinde tanımlandığı gibi), çünkü değiştirilebilir bir yineleyicinin değer türü Atanabilir olmalıdır ve çift Atanabilir değildir. Bununla birlikte, bir Çift İlişkilendirilebilir Konteyner, tamamen sabit olmayan yineleyiciler sağlayabilir: (* i) .second = d ifadesi geçerli olacak şekilde yineleyiciler.

İlk

Harita, haritaya yeni bir öğe eklemenin mevcut öğeleri gösteren yineleyicileri geçersiz kılmaması gibi önemli bir özelliğe sahiptir. Bir öğenin haritadan silinmesi, elbette silinen öğeye gerçekten işaret eden yineleyiciler dışında hiçbir yineleyiciyi geçersiz kılmaz.

İkincisi, aşağıdaki kod iyidir

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

Bir işlev çağrılırken, parametreler o işlev çağrılmadan önce değerlendirilir.

Bu nedenle, iter ++ silme çağrısından önce değerlendirildiğinde, yineleyicinin ++ operatörü geçerli öğeyi döndürür ve çağrıdan sonra bir sonraki öğeyi işaret eder.

IMHO remove_if()muadili yoktur .
Bir haritayı yeniden sıralayamazsınız.
Böylece remove_if()ilgilendiğiniz çiftleri arayabileceğiniz sonuna koyamazsınız erase().

Dayanarak Demir Kurtarıcımız'ın cevap std fonksiyonel alma Yineleyicilerin çizgisinde daha bir dizi sağlamak istiyorum olanlar için.

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Öğeleri kaybetmenin ve bunu yineleyiciden almanın bir yolu olup olmadığını merak ediyorum .

Steve Folly'nin cevabı Daha verimli hissediyorum.

İşte başka bir kolay ama daha az verimli çözüm :

Çözüm, remove_copy_ifistediğimiz değerleri yeni bir kaba kopyalamak için kullanır , ardından orijinal kabın içeriğini yenisininkilerle değiştirir:

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'den büyük anahtara sahip tüm öğeleri silmek istiyorsanız, en iyi yol

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

Herhangi bir yüklem için değil, yalnızca aralıklar için çalışır.

Ben böyle kullanıyorum

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