blocks|key|675226|text|差不多了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|675227|for(;+iter+!=+endIter;+)+{
+++++if+(Some+Condition)+{
++++++++++iter+=+aMap.erase(iter);
+++++}+else+{
++++++++++%2B%2Biter;
+++++}
}|code-block|syntax|javascript|675228|如果您确实从迭代器中删除了一个元素，那么您最初拥有的东西将使迭代器递增两次；您可能会跳过需要删除的元素。|675229|这是我见过的一种常见算法，在很多地方都有使用和记录。|675230|编辑你是正确的，迭代器在擦除之后是无效的，但只有引用被擦除的元素的迭代器，其他迭代器仍然有效。因此，在erase()调用中使用iter%2B%2B。|offset|length|style|CODE|675231|entityMap^0|0|0|0|0|1F|7|1R|6|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Almost. 

<pre><code>for(; iter != endIter; ) {
 if (Some Condition) {
 iter = aMap.erase(iter);
 } else {
 ++iter;
 }
}
</code></pre>

What you had originally would increment the iterator twice if you did erase an element from it; you could potentially skip over elements that needed to be erased.

This is a common algorithm I've seen used and documented in many places.

[EDIT] You are correct that iterators are invalidated after an erase, but only iterators referencing the element that is erased, other iterators are still valid. Hence using <code>iter++</code> in the <code>erase()</code> call.

blocks|key|675286|text|我从excellent+SGI+STL+reference上得到了这份文档|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|675287|675288|映射具有一个重要属性，即在映射中插入新元素不会使指向现有元素的迭代器无效。从map中擦除元素也不会使任何迭代器无效，当然，除了实际指向要擦除的元素的迭代器。|blockquote|675289|675290|675291|所以，你所拥有的指向要擦除的元素的迭代器当然会失效。这样做：|675292|if+(some+condition)
{
++iterator+here=iter%2B%2B;
++aMap.erase(here)
}|code-block|syntax|javascript|675293|entityMap|0|LINK|mutability|MUTABLE|url|http://www.sgi.com/tech/stl/Map.html^0|2|R|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|13|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|14|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|17|8|@]|9|@]|C|$O|P]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

I got this documentation from the <a href="http://www.sgi.com/tech/stl/Map.html" rel="nofollow noreferrer">excellent SGI STL reference</a>:

<blockquote>
 Map has the important property that
 inserting a new element into a map
 does not invalidate iterators that
 point to existing elements. Erasing an
 element from a map also does not
 invalidate any iterators, except, of
 course, for iterators that actually
 point to the element that is being
 erased.
</blockquote>

So, the iterator you have which is pointing at the element to be erased will of course be invalidated. Do something like this:

<pre><code>if (some condition)
{
 iterator here=iter++;
 aMap.erase(here)
}
</code></pre>

blocks|key|3895201|text|从下面的注释开始：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3895202|http://www.sgi.com/tech/stl/PairAssociativeContainer.html|offset|length|3895203|Pair+Associative+Container不能提供可变迭代器(如简单迭代器要求中所定义的)，因为可变迭代器的值类型必须是可赋值的，而pair是不可赋值的。然而，成对关联容器可以提供不完全恒定的迭代器:迭代器，使得表达式(*i).second+=d是有效的。|3895204|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1L|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

From the bottom notes of:

<a href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html" rel="nofollow noreferrer">http://www.sgi.com/tech/stl/PairAssociativeContainer.html</a>

a Pair Associative Container cannot provide mutable iterators (as defined in the Trivial Iterator requirements), because the value type of a mutable iterator must be Assignable, and pair is not Assignable. However, a Pair Associative Container can provide iterators that are not completely constant: iterators such that the expression (*i).second = d is valid.

blocks|key|1203782|text|IMHO没有remove_if()的等价物。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1203783|不能对地图进行重新排序。|1203784|因此，remove_if()不能将您的兴趣对放在可以调用erase()的末尾。|1203785|entityMap^0|6|B|0|0|3|B|S|7|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

IMHO there is no <code>remove_if()</code> equivalent. 
You can't reorder a map. 
So <code>remove_if()</code> can not put your pairs of interest at the end on which you can call <code>erase()</code>.

blocks|key|3895272|text|Steve+Folly's+answer我觉得效率越高。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3895273|下面是另一个简单但效率较低的解决方案：|style|BOLD|3895274|该解决方案使用remove_copy_if将我们需要的值复制到新容器中，然后将原始容器的内容与新容器的内容交换：|CODE|3895275|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);|code-block|syntax|javascript|3895276|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/800955/removeif-equivalent-for-stdmap/800984#800984^0|0|K|0|0|E|4|0|7|E|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@$A|12|B|13|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|14|8|@$A|15|B|16|F|J]]|9|@]|C|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|C|$N|O]]|$1|P|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

<a href="https://stackoverflow.com/questions/800955/removeif-equivalent-for-stdmap/800984#800984">Steve Folly's answer</a> I feel the more efficient.

Here is another easy-but-less efficient solution: 

The solution uses <code>remove_copy_if</code> to copy the values we want into a new container, then swaps the contents of the original container with those of the new one:

<pre><code>std::map&lt;int, std::string&gt; aMap;

...
//Temporary map to hold the unremoved elements
std::map&lt;int, std::string&gt; 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);
</code></pre>

blocks|key|675469|text|第一|type|unstyled|depth|inlineStyleRanges|entityRanges|data|675470|675471|映射具有一个重要属性，即在映射中插入新元素不会使指向现有元素的迭代器无效。从map中擦除元素也不会使任何迭代器无效，当然，除了实际指向要擦除的元素的迭代器。|blockquote|675472|675473|675474|其次，下面的代码是好的|675475|for(;+iter+!=+endIter;+)
{
++++if(Some+Condition)
++++{
++++++++aMap.erase(iter%2B%2B);
++++}
++++else
++++{
++++++++%2B%2Biter;
++++}
}|code-block|syntax|javascript|675476|调用函数时，在调用该函数之前会计算参数。|675477|因此，当在调用erase之前计算iter%2B%2B时，迭代器的%2B%2B操作符将返回当前项，并指向调用后的下一项。|675478|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|W|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|10|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|12|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

First

<blockquote>
 Map has the important property that inserting a new element into a map does not invalidate iterators that point to existing elements. Erasing an element from a map also does not invalidate any iterators, except, of course, for iterators that actually point to the element that is being erased.
</blockquote>

Second, the following code is good

<pre><code>for(; iter != endIter; )
{
 if(Some Condition)
 {
 aMap.erase(iter++);
 }
 else
 {
 ++iter;
 }
}
</code></pre>

When calling a function, the parameters are evaluated before the call to that function.

So when iter++ is evaluated before the call to erase, the ++ operator of the iterator will return the current item and will point to the next item after the call.

blocks|key|675518|text|如果您想擦除所有key大于2的元素，那么最好的方法是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|675519|map.erase(map.upper_bound(2),+map.end());|code-block|syntax|javascript|675520|不过，它只适用于范围，而不适用于任何谓词。|675521|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you want to erase all elements with key greater than 2, then the best way is

<pre><code>map.erase(map.upper_bound(2), map.end());
</code></pre>

Works only for ranges though, not for any predicate.

blocks|key|1203863|text|原始代码只有一个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1203864|for(;+iter+!=+endIter;+%2B%2Biter)
{
++++if(Some+Condition)
++++{
++++++++//+is+it+safe+?
++++++++aMap.erase(iter%2B%2B);
++++}
}|code-block|syntax|javascript|1203865|在这里，iter在for循环中递增一次，在erase中递增一次，这可能会在某个无限循环中结束。|offset|length|style|CODE|1203866|entityMap^0|0|0|4|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The original code has only one issue:

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

Here the <code>iter</code> is incremented once in the for loop and another time in erase, which will probably end up in some infinite loop.

blocks|key|4739434|text|用于std::map+(和其他容器)的erase_if|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4739435|我使用下面的模板来做这件事。|4739436|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+%2B%2Bit;
++++}
++}
}|code-block|syntax|javascript|4739437|这不会返回任何内容，但会从std::map中删除这些项。|4739438|使用示例：|4739439|//+'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+*/;
});|4739440|第二个示例(允许您传入测试值)：|4739441|//+'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
});|4739442|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

<h2>erase_if for std::map (and other containers)</h2>

I use the following template for this very thing.

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

This won't return anything, but it will remove the items from the std::map.

Usage example:

<pre><code>// '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&amp; item ) {
 return /* insert appropriate test */;
});
</code></pre>

Second example (allows you to pass in a test value):

<pre><code>// '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, [&amp;test_value]( item_type&amp; item ) {
 return item.property &lt; test_value; // or whatever appropriate test
});
</code></pre>

blocks|key|1203959|text|基于Iron+Savior's+answer为那些想要提供更接近于标准泛函迭代器的范围的人。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1203960|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+%2B%2Bit;
++++}
}|code-block|syntax|javascript|1203961|好奇是否有一些方法可以丢失ContainerT项并从迭代器中获得它。|style|CODE|1203962|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/16597048/37558^0|2|K|0|0|0|D|A|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Based on <a href="https://stackoverflow.com/a/16597048/37558">Iron Savior's answer</a> For those that would like to provide a range more along the lines of std functional taking iterators.

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

Curious if there is some way to lose the <code>ContainerT</code> items and get that from the iterator.

blocks|key|675706|text|现在，可以在header+<experimental/map>中使用std::experimental::erase_if。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|675707|请参阅：http://en.cppreference.com/w/cpp/experimental/map/erase_if|675708|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/experimental/map/erase_if^0|D|I|Y|R|0|4|1M|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@$9|V|A|W|1|X]]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Now, <code>std::experimental::erase_if</code> is available in header <code>&lt;experimental/map&gt;</code>.

See: <a href="http://en.cppreference.com/w/cpp/experimental/map/erase_if" rel="noreferrer">http://en.cppreference.com/w/cpp/experimental/map/erase_if</a>

blocks|key|1196569|text|我是这样使用的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1196570|+std::map<int,+std::string>+users;++++
+for(auto+it+=+users.begin();+it+<=+users.end())+{
++++if(<condition>){
++++++it+=+users.erase(it);
++++}+else+{
++++%2B%2Bit;
++++}
+}|code-block|syntax|javascript|1196571|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I use like this

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

blocks|key|1204049|text|这里有一些优雅的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204050|for+(auto+it+=+map.begin();+it+!=+map.end();)
{+++
++++(SomeCondition)+?+map.erase(it%2B%2B)+:+(%2B%2Bit);
}|code-block|syntax|javascript|1204051|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is some elegant solution.

<pre><code>for (auto it = map.begin(); it != map.end();)
{ 
 (SomeCondition) ? map.erase(it++) : (++it);
}
</code></pre>

blocks|key|4739554|text|对于使用C%2B%2B20的用户，有针对和的内置std::erase_if函数|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4739555|std::unordered_map<int,+char>+data+{{1,+'a'},{2,+'b'},{3,+'c'},{4,+'d'},
++++++++++++++++++++++++++++++++++++{5,+'e'},{4,+'f'},{5,+'g'},{5,+'g'}};
+
const+auto+count+=+std::erase_if(data,+[](const+auto&+item)+{
++++auto+const&+[key,+value]+=+item;
++++return+(key+&+1)+==+1;
});|code-block|syntax|javascript|4739556|entityMap^0|4|5|K|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

For those on C++20 there are built-in std::erase_if functions for <a href="https://en.cppreference.com/w/cpp/container/map/erase_if" rel="nofollow noreferrer">map</a> and <a href="https://en.cppreference.com/w/cpp/container/unordered_map/erase_if" rel="nofollow noreferrer">unordered_map</a>:
<pre><code>std::unordered_map&lt;int, char&gt; data {{1, 'a'},{2, 'b'},{3, 'c'},{4, 'd'},
 {5, 'e'},{4, 'f'},{5, 'g'},{5, 'g'}};
 
const auto count = std::erase_if(data, [](const auto&amp; item) {
 auto const&amp; [key, value] = item;
 return (key &amp; 1) == 1;
});
</code></pre>

I was trying to erase a range of elements from map based on particular condition. How do I do it using STL algorithms?

Initially I thought of using <code>remove_if</code> but it is not possible as remove_if does not work for associative container.

Is there any "remove_if" equivalent algorithm which works for map ?

As a simple option, I thought of looping through the map and erase. But is looping through the map and erasing a safe option?(as iterators get invalid after erase)

I used following example:

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

int main(void) 
{

 std::map&lt;int, std::string&gt; 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&lt;int, std::string&gt;::iterator iter = aMap.begin();
 std::map&lt;int, std::string&gt;::iterator endIter = aMap.end();

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

 return 0;
}
</code></pre>

remove_if equivalent for std::map

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我试图根据特定条件从map中删除一系列元素。如何使用STL算法完成此任务？最初，我想使用remove_if，但这是不可能的，因为remove_if不适用于关联容器。有没有适用于map的"remove_if“等价算法？作为一个简单的选择，我想到了遍历地图和擦除。但是遍历map和擦除是否是一个安全的选项呢？(因为迭代器在擦...

问std::map的remove_if等效项
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::map的remove_if等效项EN