[英]Adapting Map Iterators Using STL/Boost/Lambdas
Consider the following non-working code: 请考虑以下非工作代码:
typedef map<int, unsigned> mymap;
mymap m;
for( int i = 1; i < 5; ++i )
m[i] = i;
// 'remove' all elements from map where .second < 3
remove_if(m.begin(), m.end(), bind2nd(less<int>(), 3));
I'm trying to remove elements from this map where .second < 3
. 我正在尝试从这个地图中删除
.second < 3
元素。 This obviously isn't written correctly. 这显然写得不正确。 How do I write this correctly using:
如何使用以下方法正确编写:
bind
+ less<>
but without having to write a custom functor bind
+ less<>
标准STL函数对象和技术,但无需编写自定义函子 I know I'm not erase
ing the elements. 我知道我不会
erase
元素。 Don't worry about that; 别担心; I'm just simplifying the problem to solve.
我只是简化要解决的问题。
I'm not sure how to do this using just the STL binders but I think your main problem is that what's being passed into the functor you give to remove
isn't just an int
but a pair<int, unsigned>
. 我不确定如何仅使用STL绑定器来执行此操作,但我认为您的主要问题是传递给您要
remove
的仿函数的不仅仅是一个int
而是一pair<int, unsigned>
。
Using boost::bind you'd do it like this: 使用boost :: bind你会这样做:
remove_if(m.begin(), m.end(), bind(&std::pair<int, unsigned>::second, _1) < 3);
Using a lambda function it's something like this: 使用lambda函数,它是这样的:
remove_if(m.begin(), m.end(), [](const std::pair<int, unsigned>& p) { return p.second < 3; } );
I haven't checked that this compiles, sorry. 我没有检查过这个编译,对不起。
remove_if
will not work with associative containers. remove_if
不适用于关联容器。 But remove_copy_if
may work but at the expense of copying your map. 但
remove_copy_if
可能会起作用,但代价是复制地图。 Instead I'll do it with count_if
. 相反,我会用
count_if
来做。
1) Standard STL function objects & techniques using bind + less<> but without having to write a custom functor 1)使用bind + less <>的标准STL函数对象和技术,但不必编写自定义函子
// I don't think it can be done with standard c++ without introducing new functors and adaptors.
std::size_t count = std::count_if( m.begin(), m.end(),
std::sgi::compose1(
std::bind_2nd( std::less<int>(), 3 ),
&boost::get<1,mymap::value_type> ) );
2) Boost.Bind 2)Boost.Bind
std::size_t count = std::count_if( m.begin(), m.end(),
boost::compose_f_gx(
&boost::bind( std::less<int>, _1, 3 )
&boost::get<1,mymap::value_type> ) );
3) C++0x Lambdas 3)C ++ 0x Lambdas
std::size_t count = std::count_if( m.begin(), m.end(),
[]( const mymap::value_type& item )
{ return item.second < 3; } );
If you really want remove_if behavior you'll need to roll your own algorithm. 如果你真的想要remove_if行为,你需要推出自己的算法。 I don't believe there are any modifying standard algorithms that work with associative containers.
我不相信有任何修改标准算法可以使用关联容器。
template< typename FwdIter, typename AssocCont, typename Pred >
std::size_t assoc_remove_if( FwdIter iter, FwdIter end, AssocCont& cont, Pred pred )
{
std::size_t count = 0;
while( iter != end )
{
if( pred(*iter) )
{
++count;
iter = cont.erase(iter);
}
else
{
++iter;
}
}
return count;
}
Although I could not get the remove_if
algorithm to work for the reasons mentioned above, I got count_if
algorithm to work with somewhat elaborate functor definitions and compositions. 虽然由于上面提到的原因我无法使
remove_if
算法工作,但我得到了count_if
算法来处理一些精心设计的函子定义和组合。 These are not defined in the standard but they are inspired from what is available in SGI STL . 这些没有在标准中定义,但它们受到SGI STL可用的启发。
template <class Pair>
struct select2nd : std::unary_function<Pair, typename Pair::second_type>
{
typedef std::unary_function<Pair, typename Pair::second_type> super;
typedef typename super::result_type result_type;
typedef typename super::argument_type argument_type;
result_type & operator ()(argument_type & p) const {
return p.second;
}
result_type const & operator ()(argument_type const & p) const {
return p.second;
}
};
template <class UnaryFunc1, class UnaryFunc2>
struct unary_compose : std::unary_function<typename UnaryFunc2::argument_type,
typename UnaryFunc1::result_type>
{
typedef std::unary_function<typename UnaryFunc2::argument_type,
typename UnaryFunc1::result_type> super;
typedef typename super::result_type result_type;
typedef typename super::argument_type argument_type;
UnaryFunc1 func1_;
UnaryFunc2 func2_;
unary_compose(UnaryFunc1 f1, UnaryFunc2 f2) : func1_(f1), func2_(f2) {}
result_type operator () (argument_type arg) {
return func1_(func2_(arg));
}
};
template <class UnaryFunc1, class UnaryFunc2>
unary_compose<UnaryFunc1, UnaryFunc2>
compose1(UnaryFunc1 f1, UnaryFunc2 f2) {
return unary_compose<UnaryFunc1, UnaryFunc2>(f1,f2);
};
int main(void) {
typedef std::map<int, unsigned> mymap;
mymap m;
for(int i = 0; i < 5; ++i )
m[i] = i;
std::cout << "Count = "
<< std::count_if(m.begin(), m.end(),
compose1(std::bind2nd(std::less<int>(), 3), select2nd<mymap::value_type>()))
<< std::endl;
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.