仿函数 ( 函数对象 ) 详解
在C语言中我们是如何实现函数的传递呢？
没错就是函数指针!
template
void Say(T a)
{
cout << a << endl;
}
void All_Fuc(int arr[], int len,void(*say)(int))
{
for (int i = 0; i < len; i++)
say(arr[i]);
}
int main()
{
int arr[5] = { 1, 2, 3, 4, 5 };
All_Fuc(arr,5,Say);
return 0;
}
在C++中我们又可以如何去实现仿函数呢？
那就是仿函数(函数符、函数对象).
如何实现呢？
如果我们在一个类中重载了()运算符。那么这个类的对象就可以像调用函数一样去调用 。
template
class Say
{
public:
void operator() (T a)
{
cout << a << endl;
}
};
template
void All_Fuc(int arr[], int len,T func)
{
for (int i = 0; i < len; i++)
func(arr[i]);
}
int main()
{
int arr[5] = { 1, 2, 3, 4, 5 };
All_Fuc(arr, 5, Say());
return 0;
}
当然大家可以看到以上两段代码中除了函数的定义方式不一样(一个是用的函数，一个是用的类重载() ), 在主函数中调用的时候也有一点点小区别，就是在传递的时候。如果是函数指针我们写的是函数名Say,但是如果是仿函数我们写的是Say
好,在上面两个例子中大家已经能够知道什么是仿函数，以及仿函数定义出来如何使用。那么现在问题来了,为什么要使用仿函数呢？它和普通函数区别在哪儿呢？
一.仿函数和普通函数的区别
仿函数是“smart functions”(智能型函数),一般来说我们让一个函数保存状态。使得每次调用函数会因状态不同而执行效果不同。我们一般的做法都是在函数内部定义static变量。但是这是全局变量！所以说，如果使用仿函数，其状态完全可以由自身的一个成员变量来记录。事实上，你还可以在程序中同时拥有两种状态的实体，而这个是用普通函数无法实现的。
template
class Functor
{
public:
enum Type{Plus,Sub};
Functor(Type t = Plus) :type(t){}
T operator()(T a, T b)
{
if (type == Plus) return a + b;
return a - b;
}
private:
Type type;
};
int main()
{
//同时定义了一个加法器和一个减法器。
Functor plus(Functor::Plus);
Functor sub(Functor::Sub);
int a = 5, b = 3;
cout << plus(a, b) << endl;
cout << sub(a, b) << endl;
return 0;
} 当然不是任何时候使用这种特效都是很好的。换句话就是说尽量不要在重载()函数中去改变对象的状态。我们通过举例来看：
class Average
{
public:
Average():count(0), sum(0){ }
void operator()(double num) //每次调用这个仿函数就相当于往里面添加了一个数
{
count++;
sum += num;
}
double GetAverage(){ return sum / count; } //最后由这个方法得到当前的平均值
private:
int count;
double sum;
};
template < class T ,class F>
void For_each(T begin, T end, F functor) //这是一个手动实现的一个简单的for_each.
{
for (T it = begin; it != end; it++)
functor(*it);
}
int main()
{
vector arr = { 1, 2, 3, 4, 5 };
Average result;
For_each(arr.begin(), arr.end(), result);
cout << result.GetAverage() << endl;
return 0;
} 这里提供第二个方法的实现(库函数的for_each也正是这样实现的)：
class Average
{
//同上
};
template < class T ,class F>
F For_each(T begin, T end, F functor)
{
for (T it = begin; it != end; it++)
functor(*it);
return functor;
}
int main()
{
vector arr = { 1, 2, 3, 4, 5 };
Average result = For_each(arr.begin(), arr.end(), Average()); //这里的Average()相当于一个临时对象
cout << result.GetAverage() << endl;
return 0;
}
二.仿函数的一些基本概念
生成器(generator)是不用参数就可以调用的函数符(仿函数)。
一元函数(unary function) 是用一个参数就可以调用的函数符。
二元函数(binary function)是用两个参数就可以调用的函数符。
例如：供给给for_each()的函数符应该是一个一元函数，因为它每次用于一个容器元素。
当然，这些概念都有相应的改进版：
返回bool值的一元函数是谓词(predicate)；
返回bool值的二元函数是二元谓词(binary predicate)。
例如：供给给sort函数的第三个参数就应该是一个二元谓词，表示一个优先级关系。
三.仿函数在STL中的定义
在STL中也为我们准备好了一些常用的仿函数。
这里是头文件 => #include
| 仿函数 |
效果 |
| negate |
-param |
| plus |
param1+param2 |
| minus |
param1-param2 |
| multiplies |
param1*param2 |
| divides |
param1/param2 |
| modulus |
param1%param2 |
| equal_to |
param1==param2 |
| not_equal_to |
param!=param2 |
| less |
param1 |
| greater |
param1>param2 |
| less_equal |
param1<=param2 |
| greater_equal |
param1>=param2 |
| logical_not |
!param |
| logical_and |
param1&¶m2 |
| logical_or |
param1||param2 |
四.自适应函数符
什么叫自适应呢？其实很简单，我举个例子来说，假如我想实现一个对Vector所有元素求积的功能.(假定元素类型为整数或者实数)
template
class Mul
{
public:
T operator()(T a,T b)
{
return a*b;
}
};
template < class T ,class F>
____ For_each(T begin, T end, F functor)
{
____ ans = 1;
for (T it = begin; it != end; it++)
ans = functor(*it,ans);
return ans;
}
int main()
{
vector arr = { 1, 2, 3, 4, 5 };
int ans = For_each(arr.begin(), arr.end(), Mul());
cout << ans << endl;
return 0;
}
template
class Mul
{
public:
T operator()(T a, T b)
{
return a*b;
}
typedef T first_argument_type, second_argument_type, result_type;
}; 这样就相当于对这个二元函数符记录了它的两个参数和返回类型。所以我们的For_each就可以这样相应的写：
template < class T, class F>
typename F::result_type For_each(T begin, T end, F functor) //因为在这里编译器不知道result_type是F的成员变量还是类型,所以要用关键字typename限定。
{
typename F::result_type ans = 1;
for (T it = begin; it != end; it++)
ans = functor(*it, ans);
return ans;
}所以我们把有这样的记录了参数、返回值类型的仿函数称之为自适应的仿函数。在库函数中，为我们准备好了两个类型：std::unary_function 和 std::binary_function
我们先看看源码吧：
template
struct unary_function
{ // base class for unary functions
typedef _Arg argument_type;
typedef _Result result_type;
};
// TEMPLATE STRUCT binary_function
template
struct binary_function
{ // base class for binary functions
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};
template
class Mul : public unary_function
{
public:
T operator()(T a, T b)
{
return a*b;
}
};
五.函数适配器(函数配接器)
对于函数适配器，书上比较正式的解释是：标准库提供了一组函数适配器（function adapter），用于特化和扩展一元和二元函数对象。
而我的理解：函数配适器就是改变函数符的输入或者输出使得原本的函数符功能特化。所以我觉得叫做函数修饰器更比较贴切吧(个人感觉)。
在库中提供的函数适配器分为两类：
（1）绑定器（binder），是一种函数适配器，它通过将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象。
（2）求反器（negator），是一种函数适配器，它将谓词函数对象的真值求反。
先举例绑定器：例如上文中我写的Mul仿函数，这个仿函数是一个二元函数,他需要给出两个参数。但是如果其中一个参数已经确定了。那么其实这个二元函数就可以退化为一个一元函数。所以这时候就需要绑定器来实现"类型转换"。假如：Mul中第二个参数已经固定为3，那么退化后的一元函数就为：bind2nd(Mul
给出一个例子吧，假如我要实现这样一个代码：Vector存放了若干个整数，现在输入一个整数x，问Vector的所有整数在数轴上与x的距离和为多少？
( 假如Vector存放的是1,5,8，x = 3, 那么和为 abs(1-3)+abs(5-3)+abs(8-3) ) 我们可以看到求距离的这个仿函数应该是一个二元函数。需要提供两个整数。但是我们知道其中一个整数是固定为x的所以我们的代码可以这么写：
class Dis :public binary_function
{
public:
int operator()(int a, int b) const //要用绑定器的函数符必须为const重载()函数.
{
if (a > b) return a - b;
return b - a;
}
};
template < class T, class F>
typename F::result_type For_each(T begin, T end, F functor)
{
typename F::result_type ans = 0;
for (T it = begin; it != end; it++)
ans += functor(*it);
return ans;
}
int main()
{
vector arr = { 1, 3, 4, 5, 6, 9, 10 };
int x = 3;
//cin >> x;
int ans = For_each(arr.begin(), arr.end(), bind2nd(Dis(), x));
cout << ans << endl;
return 0;
} 常用绑定器有两个：bind1st, bind2nd，分别是把值绑定到二元函数的第一个参数或者是第二个参数。至于求反器我就不过多说明了。其实适配器并不只限定于这两种。完全可以根据我们自己的要求来写各种适配器。例如我这里写了一个适配器。Unity 其作用就是 这个复合函数(这里的函数是数学的中的复合函数) : H(F(x), G(x)); 其实除了上面两种适配器还有一种可应当可以称之为适配器就是成员函数适配器。 有时候，你可能想让算法调用容器元素的成员函数，而不是外部函数。因为外部无法改变对象内的状态，且内部函数通常具有更高的效率。例如swap(string, string)总是没有string.swap(string)快速。又比如sort无法对list进行排序，这时候只能使用list.sort()来给链表排序。这时候就需要使用一定的方法将对象内部的函数“变成”函数对象，这样的函数对象叫做成员函数适配器。 其实成员函数适配器是一个一元函数，参数为调用这个成员函数的对象(或者对象指针)。当然如果是对象的话适配器就是mem_fun_ref如果是指针的话就是mem_fun。 我们来举例说明一下，例如：定义一个类Student,有个成员变量为学生名字，有一个成员函数为Say即是输出这个学生的名字。现在我们有一个vector
参考资料： c++中的函数对象： http://blog.csdn.net/bonchoix/article/details/8050627 函数对象(仿函数)： http://www.cnblogs.com/weiqubo/archive/2011/02/16/1956552.html 仿函数： http://blog.csdn.net/ggz631047367/article/details/38058245class Unity : unary_function < typename F::argument_type, typename H::result_type >
{
public:
Unity(const H &h, const F &f, const G &g) :m_h(h), m_f(f), m_g(g) { }
typename H::result_type operator() (typename F::argument_type x) const
{
return m_h(m_f(x), m_g(x));
}
private:
H m_h;
F m_f;
G m_g;
};
template
class Student
{
public:
explicit Student(string n = "测试学生") :name(n){}
void Say(){ cout << name << endl; }
private:
string name;
};
template