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

สิ่งที่คุณมีในตอนแรกจะเพิ่มตัววนซ้ำสองครั้งหากคุณลบองค์ประกอบออกจากมัน คุณอาจข้ามองค์ประกอบที่จำเป็นต้องลบได้

นี่เป็นอัลกอริทึมทั่วไปที่ฉันเคยเห็นใช้และบันทึกไว้ในหลาย ๆ ที่

[แก้ไข] คุณถูกต้องที่ตัวทำซ้ำจะไม่ถูกต้องหลังจากลบไปแล้ว แต่มีเพียงตัวทำซ้ำที่อ้างถึงองค์ประกอบที่ถูกลบไปแล้วตัวทำซ้ำอื่น ๆ ยังคงใช้ได้ ดังนั้นการใช้iter++ในerase()โทร

erase_if สำหรับ std :: map (และคอนเทนเนอร์อื่น ๆ )

ฉันใช้เทมเพลตต่อไปนี้สำหรับสิ่งนี้

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

Pair Associative Container ไม่สามารถจัดเตรียมตัวทำซ้ำที่เปลี่ยนแปลงได้ (ตามที่กำหนดไว้ในข้อกำหนด Trivial Iterator) เนื่องจากชนิดค่าของตัววนซ้ำที่เปลี่ยนแปลงได้ต้องเป็น Assignable และคู่ไม่สามารถกำหนดได้ อย่างไรก็ตาม Pair Associative Container สามารถจัดเตรียมตัววนซ้ำที่ไม่คงที่อย่างสมบูรณ์: ตัวทำซ้ำเพื่อให้นิพจน์ (* i) .second = d ถูกต้อง

เป็นครั้งแรก

แผนที่มีคุณสมบัติที่สำคัญที่การแทรกองค์ประกอบใหม่ลงในแผนที่ไม่ทำให้ตัวแสดงซ้ำที่ชี้ไปยังองค์ประกอบที่มีอยู่เป็นโมฆะ การลบองค์ประกอบออกจากแผนที่จะไม่ทำให้ตัวทำซ้ำใด ๆ เป็นโมฆะยกเว้นแน่นอนสำหรับตัวทำซ้ำที่ชี้ไปยังองค์ประกอบที่กำลังถูกลบ

ประการที่สองรหัสต่อไปนี้ดี

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

เมื่อเรียกใช้ฟังก์ชันพารามิเตอร์จะได้รับการประเมินก่อนการเรียกใช้ฟังก์ชันนั้น

ดังนั้นเมื่อมีการประเมิน iter ++ ก่อนการเรียกให้ลบตัวดำเนินการ ++ ของตัวทำซ้ำจะส่งคืนรายการปัจจุบันและจะชี้ไปที่รายการถัดไปหลังจากการเรียก

IMHO ไม่มีทางremove_if()เทียบเท่า
คุณไม่สามารถจัดลำดับแผนที่ใหม่ได้
ดังนั้นremove_if()ไม่สามารถใส่คู่ที่คุณสนใจในตอนท้ายที่คุณสามารถโทรerase()ได้

จากคำตอบของ Iron Saviorสำหรับผู้ที่ต้องการให้ช่วงเพิ่มเติมตามบรรทัดของการทำซ้ำฟังก์ชันมาตรฐาน

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ไอเท็มและรับสิ่งนั้นจากตัววนซ้ำ

คำตอบของ Steve Follyฉันรู้สึกว่ามีประสิทธิภาพมากขึ้น

นี่เป็นอีกหนึ่งวิธีแก้ปัญหาที่ง่าย แต่มีประสิทธิภาพน้อย :

โซลูชันนี้ใช้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;
    }
 }