仿函数三大妙处：
1、仿函数比一般函数更灵巧，因为它可以拥有状态。事实上对于仿函数，你可以同时拥有两个状态不同的实体。
2、每个仿函数都有其型别。因为你可以将仿函数的型别当作template参数来传递，从而指定某种行为模式，容器型别也会因为仿函数的不同而不同。
3、执行速度上，仿函数通常比函数指针更快。就template概念而言，很多细节在编译期就已确定。
仿函数是以by value方式传递的好处是，你可以传递常量或暂时表达式，如果不这样设计，就不能传递ClassName(1)这样的表达式（临时对象），至于缺点是无法改变仿函数的状态。因为你改变的只是副本而已。然而我们有时候确实需要存取最终状态。因此，问题在于如何从一个算法中获取结果。
有两个办法可以从“运用了仿函数”的算法中获取“结果”或“反馈”。
1、以by reference的方式传递仿函数（仅限参考，不一定管用）
2、运用for_each()算法的回返值
例1：by reference（在vs2013上不管用，原因如注释）
#include <iostream>
#include <list>
#include<algorithm>
#include<iterator>
using namespace std;
class IntSequence{
private:
int value;
public:
IntSequence(int initialValue) :value(initialValue){};
int operator()()
{
return value++;
}
};
int main()
{
list<int> coll;
IntSequence seq(1);
generate_n<back_insert_iterator<list<int>>, int, IntSequence&>(back_inserter(coll), 4, seq);//在该算法内部，调用了另外的模板 //进行了传值，而不是by reference
copy(coll.begin(), coll.end(), ostream_iterator<int>(cout, " "));
cout << endl;
generate_n(back_inserter(coll), 4, IntSequence(42));
generate_n(back_inserter(coll), 4, seq);
copy(coll.begin(), coll.end(), ostream_iterator<int>(cout, " "));
cout << endl;
system("pause");
return 0;
}
例2：for_each()
#include <iostream>
#include <vector>
#include<algorithm>
#include<iterator>
using namespace std;
class MeanValue{
private:
long num;
long sum;
public:
MeanValue() :num(0), sum(0){}
void operator()(int elem)
{
num++;
sum += elem;
}
double value()
{
return static_cast<double>(sum) / static_cast<double>(num);
}
};
int main()
{
vector<int> coll;
for (int i = 1; i <= 8; ++i)
{
coll.push_back(i);
}
MeanValue mv = for_each(coll.begin(), coll.end(), MeanValue());
cout <<"mean value"<<mv.value()<< endl;
system("pause");
return 0;
}
输出：mean value4.5
一个陷阱：
#include <iostream>
#include <list>
#include<algorithm>
#include<iterator>
using namespace std;
class Nth{
private:
int nth;
int count;
public:
Nth(int n) :nth(n), count(0){}
bool operator()(int){
return ++count == nth;
}
};
int main()
{
list<int> coll;
for (int i = 1; i <= 9; ++i)
{
coll.push_back(i);
}
copy(coll.begin(), coll.end(), ostream_iterator<int>(cout, " "));
cout << endl;
list<int>::iterator pos;
pos = remove_if(coll.begin(), coll.end(), Nth(3));
coll.erase(pos, coll.end());
copy(coll.begin(), coll.end(), ostream_iterator<int>(cout, " "));
cout << endl;
system("pause");
return 0;
}
输出：
1 2 3 4 5 6 7 8 9
1 2 4 5 7 8 9 //3和6都被删除了
下面是remove_if的一般实作：
template<class ForwIter,class Predicate>
ForwIter std::remove_if(ForwIter beg, ForwIter end, Predicate op)
{
beg = find_if(beg, end, op);
if (beg == end)
{
return beg;
}
else
{
ForwIter next = beg;
return remove_copy_if(++next, end, beg, op);
}
}
find_if传值，remove_copy_if中op的count从零开始，即在实施删除时又进行了一次删除。
解决方法：总是将判断式operator()声明为const成员函数。
预定义的仿函数：
#include<functional>
|
仿函数 |
效果 |
|
negate<type>() |
-param |
|
plus<type>() |
param1+param2 |
|
minus<type>() |
param1-param2 |
|
multiplies<type>() |
param1*param2 |
|
divides<type>() |
param1/param2 |
|
modulus<type>() |
param1%param2 |
|
equal_to<type>() |
param1==param2 |
|
not_equal_to<type>() |
param!=param2 |
|
less<type>() |
param1<param2 |
|
greater<type>() |
param1>param2 |
|
less_equal<type>() |
param1<=param2 |
|
greater_equal<type>() |
param1>=param2 |
|
logical_not<type>() |
!param |
|
logical_and<type>() |
param1&¶m2 |
|
logical_or<type>() |
param1||param2 |
函数配接器：
|
表达式 |
效果 |
|
bind1st(op,value) |
op(value,param) |
|
bind2nd(op,value) |
op(param,value) |
|
not1 |
!op(param) |
|
not2 |
!op(param1,param2) |
|
针对成员函数而设计的函数配接器 |
|
|
mem_fun_ref(op) |
调用op，那是某对象的一个const成员函数 |
|
mem_fun(op) |
调用op，那是某对象指针的一个const成员函数 |
|
针对一般函数而设计的函数配接器 |
|
|
ptr_fun(op) |
op(param) op(param1,param2) |
例子：mem_fun_ref
vs2013不要求成员函数为const
</pre><pre class="cpp" name="code">class Person{
private:
string name;
public:
Person(string na) :name(na){}
void print() const{
cout << name << endl;
}
void printWithPrefix(string prefix)const
{
cout << prefix << name << endl;
}
};
list<Person> coll;
for_each(coll.begin(), coll.end(), mem_fun_ref(&Person::print));
for_each(coll.begin(), coll.end(), bind2nd(mem_fun_ref(&Person::printWithPrefix), "person:"));list<Person*> coll;
for_each(coll.begin(), coll.end(), mem_fun(&Person::print));
for_each(coll.begin(), coll.end(), bind2nd(mem_fun(&Person::printWithPrefix), "person:"));
mem_fun_ref和mem_fun两者都能以无参数或单参数方式来调用成员函数。
ptr_fun:
假设有一个能对每个参数实施某种检测的全局函数如下：
bool check(int elem)
如果要搜寻第一个令检查失败的元素，可以如下：
pos=find_if(coll.begin(),coll.end(),not1(ptr_fun(check)));这里ptr_fun不可省略，因为not1()需要用到仿函数提供的某些特殊型别。
第二种用法，你有一个双参数全局函数，又想把它当成一个单参数函数使用
pos=find_if(coll.begin(),coll.end(),bind2nd(ptr_fun(strcmp),""));