STL——函数对象

函数对象的定义

重载函数调用操作符（）的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象。又称仿函数。

也可以如下定义：函数对象是重载了operator()的类的一个实例，operator()是函数调用运算符。

下面是个简单示例：

代码如下：

#include "stdafx.h"
#include<vector>
#include<iostream>
#include<functional>
#include<algorithm>
#include<numeric>
using namespace std;

class CSum
{
public:
CSum():sum(0){}
void operator()(int n){//重载函数调用运算符()
sum +=n;
}
int GetSum()const
{
return sum;
}
private:
int sum;
};

int _tmain(int argc, _TCHAR* argv[])
{
vector<int> v(100);
std::iota(v.begin(),v.end(),1);
CSum obj=std::for_each(v.begin(),v.end(),CSum());//CSum()构造函数对象，赋给obj
cout<<obj.GetSum();//结果为5050

return 0;
}

函数对象的分类

根据operator()参数个数为0个、1个、2个可以划分出以下几种类型的函数对象。

发生器：没有参数，返回一个任意类型值

一元函数：1个任意类型参数，返回一个可能不同类型值得函数对象

二元函数：2个任意类型参数，返回一个任意类型值

一元判定函数：返回bool型值得一元函数

二元判定函数：返回bool型值得二元函数

STL源码如下：

//一元函数：
//  FUNCTIONAL STUFF (from <functional>)
// TEMPLATE STRUCT unary_function
template<class _Arg,
class _Result>
struct unary_function
{   // base class for unary functions
typedef _Arg argument_type;
typedef _Result result_type;
};

二元函数
// TEMPLATE STRUCT binary_function
template<class _Arg1,
class _Arg2,
class _Result>
struct binary_function
{   // base class for binary functions
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};

应用一元函数，改进CSum代码

template<class _inPara,class _outPara>
class CSum:public unary_function<_inPara,_outPara>
{
public:
CSum():sum(0){}
void operator()(_inPara n){
sum +=n;
}
_outPara GetSum()const
{
return sum;
}
private:
_outPara sum;
};

int _tmain(int argc, _TCHAR* argv[])
{
vector<int> v(100);
std::iota(v.begin(),v.end(),1);
CSum<int,int> obj=std::for_each(v.begin(),v.end(),CSum<int,int>());//CSum<int,int>()临时函数对象，赋给obj
cout<<obj.GetSum();//结果为5050
return 0;
}

系统函数对象

STL中提供了大量的内建的函数对象，主要包含算数类、关系运算类和逻辑运算类三种。如下所示：



代码示例：

int _tmain(int argc, _TCHAR* argv[])
{
std::plus<int> ad;//加法
int sum=ad(10,20);
cout<<sum;//结果为30

return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
vector<int> v(100);
std::iota(v.begin(),v.end(),1);
int sum=std::accumulate(v.begin(),v.end(),0,std::plus<int>());
cout<<sum;//结果5050
return 0;
}

相关STL源码如下：

//累加源码
template<class _InIt,
class _Ty,
class _Fn2> inline
_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
{   // return sum of _Val and all in [_First, _Last), using _Func
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Func);
return (_Accumulate(_Unchecked(_First), _Unchecked(_Last), _Val, _Func));
}
// TEMPLATE FUNCTION accumulate WITH BINOP
template<class _InIt,
class _Ty,
class _Fn2> inline
_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
{   // return sum of _Val and all in [_First, _Last), using _Func
for (; _First != _Last; ++_First)
_Val = _Func(_Val, *_First);
return (_Val);
}

//加法plus源码
// TEMPLATE STRUCT plus
template<class _Ty>
struct plus
: public binary_function<_Ty, _Ty, _Ty>
{   // functor for operator+
_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
{   // apply operator+ to operands
return (_Left + _Right);
}
};

//减法minus源码
// TEMPLATE STRUCT minus
template<class _Ty>
struct minus
: public binary_function<_Ty, _Ty, _Ty>
{   // functor for operator-
_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
{   // apply operator- to operands
return (_Left - _Right);
}
};

//乘法，除法源码
// TEMPLATE STRUCT multiplies
template<class _Ty>
struct multiplies
: public binary_function<_Ty, _Ty, _Ty>
{   // functor for operator*
_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
{   // apply operator* to operands
return (_Left * _Right);
}
};

// TEMPLATE STRUCT divides
template<class _Ty>
struct divides
: public binary_function<_Ty, _Ty, _Ty>
{   // functor for operator/
_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
{   // apply operator/ to operands
return (_Left / _Right);
}
};