STL学习之函数对象
0.由来
Effective STL第46条：考虑使用函数对象而不是函数作为STL算法的参数
书里说到：
你或许会对本条款将要讨论的话题感到惊讶：将函数对象（即可以被伪装成函数的对象）传递给STL算法往往比传递实际的函数更高效。
书中提到了性能比较的数值：
我在4个不同的STL平台上，针对一个包含100w个double数据的vector对象测试了两种调用，并都设置了速度优化，
……最差的情况下，使用函数对象的版本快了50%，最好的情况下快了160%
书中进行了解释：
1.函数对象时，编译器将该函数内联进去了
2.使用函数时，编译器会隐式的将它转化成一个指向该函数的指针，并将该指针传递过去，而大多数编译器不会对函数指针执行的函数进行内联优化
1.理解
看书100本不如写代码1行。这里记录下整个理解过程。
在实际操作中，经常是用函数直接传给STL的，像下面这样：
1.1函数作为参数的简单代码
#define NUM 10000000
typedef std::vector<double> VecData;
typedef VecData::iterator VecDataIT;
//排序函数
inline bool doubleGreater(double d1, double d2)
{
return d1 > d2;
}
VecData data(NUM),dataplus(NUM);
std::generate(data.begin(), data.end(), rand);
//用函数做STL的参数
std::sort(data.begin(), data.end(), doubleGreater);1.2使用函数对象做参数
//引用库
#include <functional>
调用的时候
std::sort(data.begin(), data.end(), std::greater<double>());
1.3性能对比
采用高精度计时器类写的1ms精度定时器，
判断transform前后所需时间。
测试平台如下
Win10 64bit
VS2015 默认优化
基于对话框 Release模式
耗时取10次平均值
| 方法 | 耗时(ms) |
|---|---|
| 函数对象 | 900 |
| 函数 | 1600 |
结论
和书中预言的一样，使用函数对象，也就是特殊的类，反而更快。（在csdn上有人说传递函数实际上在汇编里只有2个命令，而函数对象构造一个类至少要50个命令，
但结果就是传递类进去更快）
这里函数对象时调用的库函数，库函数一般都是大神优化很多的结果，如果是自己写的函数对象呢，还能一样对函数碾压吗？
下面继续试验，试验自定义函数和函数对象，同样做1000w浮点排序
1.4稍复杂的排序
//自定义类
typedef struct _tData
{
double data1;
double data2;
_tData()
{
data1 = rand();
data2 = rand();
}
inline _tData& operator= (_tData& d)
{
data1 = d.data1;
data2 = d.data2;
return(*this);
}
inline bool operator<(_tData& d)
{
return(data1 < d.data1);
}
}Data;
typedef std::vector<Data> VecData;
//比较函数
inline bool doubleGreater(Data& d1, Data& d2)
{
return d1.data1 > d2.data1;
}排序时
std::sort(data.begin(), data.end());//doubleGreater
测试结果
| 方法 | 耗时(ms) |
|---|---|
| 函数对象 | 930 |
| 函数 | 1670 |
结论
还是一样，使用函数对象，反而更快。
2.transform的应用
将一个double向量里的数据经过一个复杂的运算赋值到另外一个double向量里去，这里对比3种方法效率
2.0数据定义
VecDouble data(NUM),datacalc(NUM);
srand((unsigned)time(NULL));
std::generate(data.begin(), data.end(), rand);2.1直接for循环法
for (UINT i = 0; i < data.size(); i++)
{ datacalc.push_back(sqrt(data[i] * 3.552 / 2.1 + 66.3)); }2.2STL模板+内联函数
inline double calc(double data)
{
return(sqrt(data * 3.552 / 2.1 + 66.3));
}调用：
std::transform(data.begin(), data.end(), datacalc.begin(), Calc());2.3STL模板+函数对象
typedef struct _Calc
{
double operator()(const double data)
{
return(sqrt(data * 3.552 / 2.1 + 66.3));
}
}Calc;调用：
std::transform(data.begin(), data.end(), datacalc.begin(), Calc());2.4性能对比
测试结果
| 方法 | 耗时(ms) |
|---|---|
| for循环 | 270 |
| 函数对象 | 58 |
| 内联函数 | 59 |
结论
STL太牛逼了，甩一直用的for循环几条街都不止，以后能用STL的都要用STL。
Effective STL第43条
算法调用优先于手写的循环
作者给出了3个理由
1.效率
2.正确性
3.可维护性
3.带参数的函数对象
上面提到的都是简单的不带参数函数对象，在STL的算法里很多是可以带参数的函数对象。
Effective STL第40条
若一个类是函数子，则应使它可配接
3.1方法
书中写到：
在STL中，4个标准的函数配接器(not1,not2,bind1st,bind2nd)都要求特殊的类型定义，而非标的，boost提供的模板很多也包含了这样的组件。提供这些类型定义最简便的方法便是让函数子从特定的基类继承。
如果函数子类的operator()只有一个实参，那么它应该从std::unary_function继承
如果函数子类的operator()有两个实参，那么它应该从std::binary_function继承
具体为：
对于
std::unary_function，必须指定函数子类operator()所带的参数的类型，以及返回类型。
对于std::binary_function，必须指定三个类型：operator()的第一个和第二个参数的类型函数子类所带的参数的类型，以及返回类型。
3.2代码
将上面的一个结构改为下面
typedef struct _Calc : public std::unary_function<double,double>
{
double operator()(const double data)
{
return(sqrt(data * 3.552 / 2.1 + 66.3));
}
}Calc;
注意： std::unary_function<double,double>里第一个double是operator()的输入参数类型，第二个double是operator()的返回类型。
3.3指针or引用
书中原话：
一般情况下，传递给
std::unary_function和std::binary_function的非指针类型要去掉const和引用&；
而如果operator()带有指针，则传递给std::unary_function和std::binary_function的类型也要为指针。