我的C++实践(12)：函数指针与仿函数

C++的函数调用语法实体有函数、类似于函数的宏、函数指针、仿函数（即函数对象）。函数调用的方式有：
（1）直接调用：通过函数名直接调用函数，函数起始地址成为指令的一部分，因此编译期就能确定调用了哪个函数。
（2）间接调用：通过函数指针来调用函数，函数起始地址位于内存或寄存器的某处，因此到运行期才能确定调用哪个函数。
（3）内联调用：直接在调用处展开函数代码，在编译期进行，因此到运行期就不存在函数调用了。
对函数指针和仿函数的使用，基本上都是某种形式的回调。通常的程序库是库作者来编写库的代码，让用户来使用这些库，而回调正好相反，程序库调用了某个函数，而这个函数的代码需要由使用库的用户来编写。在实际应用中，仿函数与函数指针相比有很多优点，因为仿函数是类对象，因此我们可以在仿函数中关联状态信息（当然这会使仿函数类占内存空间，但我们可以使用空基类优化技术），这样根据不同的参数生成不同的函数实例。仿函数可以作为模板的类型实参来传递，也可以作为函数调用实参来传递。但仿函数是类对象，因此不能作为非类型模板实参，但函数指针可以作为非模板模板实参。通过仿函数，我们可以把所有的的普通函数都封装成仿函数类，这样就可以以对象的方式来统一使用各个函数。我们也可以对仿函数的各个参数类型和返回类型进行萃取，从而使其具有反射的能力，不同的仿函数还可以方便地组合起来使用。
编写仿函数类的基本约定： 在仿函数类中要定义仿函数的参数个数常量NumParams、每个参数的类型typedef Param1T,typedef Param2T,...、返回类型tyepdef ReturnT。根据约定，我们的仿函数类应该编写成类似于下面的形式：

class PersonSort{
public:
enum(NumParams=2 };
typedef bool ReturnT;
typedef Person const& Param1T;
typedef Person const& Param2T;
bool operator()(Person const& p1,Person const& p2) const{
//返回p1是否小于p2
}
};

1、仿函数的类型萃取实现： FunctorParam<F,N>用来获取仿函数F的第N的参数的类型，当N值不大于实际的参数个数时，调用UsedFunctorParam<F,N>模板针对N的特化来获取相应位置处的参数类型，当N值大于实际的参数个数时，返回私有的无用嵌套成员类 NNest，它不能用来创建对象，因此没有副作用。代码如下：

//functorparam.hpp：获取仿函数各个参数的类型
#ifndef FUNCTOR_PARAM_HPP
#define FUNCTOR_PARAM_HPP
#include "ifthenelse.hpp"  //用到了IfThenElse模板
/*
* UsedFuctorParam<F,N>：抽取仿函数F的实际使用的第N个参数类型
*/
template <typename F, int N>
class UsedFunctorParam; //基本模板
//对每个N值，都提供一个局部特化，以获取相应位置处参数的类型
//使用宏FunctorParamSpec(N)来编写UsedFunctorParam的特化，可以使代码更简洁
#define FunctorParamSpec(N)                 /
template<typename F>                        /
class UsedFunctorParam<F, N>{               /
public:                                     /
typedef typename F::Param##N##T Type;   /
};
//假设N到20为止，很少有多于20个参数的仿函数
FunctorParamSpec(1)
FunctorParamSpec(2)
FunctorParamSpec(3)
FunctorParamSpec(4)
FunctorParamSpec(5)
FunctorParamSpec(6)
FunctorParamSpec(7)
FunctorParamSpec(8)
FunctorParamSpec(9)
FunctorParamSpec(10)
FunctorParamSpec(11)
FunctorParamSpec(12)
FunctorParamSpec(13)
FunctorParamSpec(14)
FunctorParamSpec(15)
FunctorParamSpec(16)
FunctorParamSpec(17)
FunctorParamSpec(18)
FunctorParamSpec(19)
FunctorParamSpec(20)
#undef FunctorParamSpec  //宏FunctorParamSpec的生命期结束
/*
* FunctorParam<F,N>::Type：获取仿函数F的第N个参数的类型，当N大于实际参数
* 个数F::NumParams时，FunctorParam<F,N>::Type会返回私有的无用嵌套类
* NNest，它不能用来创建对象，因此没有副作用
*/
template <typename F, int N>
class FunctorParam{
private:
class Unused{ //嵌套类
private:
class NNest {}; //嵌套的无用成员类
public:
typedef NNest Type;
};
public:
//获取相应位置处的参数类型
typedef typename IfThenElse<F::NumParams>=N,
UsedFunctorParam<F,N>,
Unused>::ResultT::Type
Type;
};
#endif

解释：
（1）UsedFuctorParam<F,N>用来抽取仿函数F的实际使用的第N个参数类型，这里N没有超过仿函数的实际参数个数。参数类型的抽取是通过对每个N值提供一个局部特化来实现的。假设仿函数的参数个数最多为20，对具有工业强度的库而言，其设计一般要达到20个参数左右。实际中很少有多于20个参数的仿函数。这里#undef表示宏FunctorParamSpec的生命期结束，即下面就已经不存在FunctorParamSpec这个宏了，要用的话需要重新定义。
（2）FunctorParam<F,N>中，N可以超过仿函数的实际参数个数，当超过时，就返回一个私有的无用嵌套类NNest，NNest在FunctorParam内部，在外部并不能直接用类名NNest来创建对象，因此对不存在的参数虽然返回了一个类型，但并没有产生副作用。这里用到了类型萃取技术中开发的IfThenElse模板。
2、把函数指针封装成仿函数： 直接对函数指针的返回类型和各个参数类型进行参数化，设计成仿函数类模板。
下面的ForwardParamT<T>用于决定仿函数的参数类型T是传引用还是传原来的普通类型，T为类类型时则传引用，其他情况则传原来的普通类型（这需要用到类型萃取技术中开发的TypeOp模板），这样可以避免昂贵的拷贝构造函数调用。对仿函数参数为空（即为void）的情况，提供一个全局特化，指定空参数的类型为一个无副作用的哑类型。

//forwardparam.hpp：ForwardParamT<T>用于决定仿函数的参数类型T是传引用还是传原来的普通类型
#ifndef FORWARD_PARAM_HPP
#define FORWARD_PARAM_HPP
#include "ifthenelse.hpp"
#include "isclasst.hpp"
#include "typeop.hpp"    //用于决定函数的参数是传引用还是传原来的类型
template<typename T>
class ForwardParamT{ //基本模板：T为类类型则传const引用，否则就传普通类型
public:
typedef typename IfThenElse<IsClassT<T>::Yes,
typename TypeOp<T>::RefConstT,
typename TypeOp<T>::ArgT
>::ResultT
Type;
};
template<>
class ForwardParamT<void>{ //全局特化：void表示函数参数为空，则传哑类型Ununsed，
private:                   //它不能创建对象，因此没有副作用
class Unused {};
public:
typedef Unused Type;
};
#endif

下面的FunctionPtrT用来根据函数指针的返回类型和各个参数类型构造出函数指针（这里针对最多为5个参数的情况，对含有更多个参数的函数原理和做法是一样的）。最后的FunctionPtr就是真正封装函数指针的仿函数类型，要遵循仿函数的编写约定。它组合一个用FunctionPtrT构造出来的函数指针，然后根据函数指针的不同实参个数（0-5个）重载operator()，并用函数指针来进行调用实际的函数即可。在调用函数时，用到了上面的ForwardParamT<T>，这样就可以在传递调用实参时避免拷贝构造函数的调用。包装函数func_ptr(*fp)用来方便地创建封装了函数指针的函数对象。

//functionptr.hpp：把最多为5个参数的函数指针类型封装成仿函数模板FunctionPtr<RT,P1,P2,P3,P4,P5>
//对含有更多个参数的函数，其原理和做法一样的
#ifndef FUNCTION_PTR_HPP
#define FUNCTION_PTR_HPP
#include "forwardparam.hpp"  //用于决定函数的形参T是传引用还是传原来的普通类型
/*
* FunctionPtrT<RT,P1,P2,P3,P4,P5>：用来根据返回类型和各个参数类型构造出函数指针
*/
template<typename RT, typename P1 = void,
typename P2 = void,
typename P3 = void,
typename P4 = void,
typename P5 = void>
class FunctionPtrT{ //基本模板：函数指针有5个参数的情况
public:
enum { NumParams = 5 }; //定义参数个数的枚举量
typedef RT (*Type)(P1,P2,P3,P4,P5); //根据参数类型来定义函数指针
};
template<typename RT, typename P1,
typename P2,
typename P3,
typename P4>
class FunctionPtrT<RT,P1,P2,P3,P4,void>{ //局部特化：4个参数的情况
public:
enum { NumParams = 4 };
typedef RT (*Type)(P1,P2,P3,P4);
};
template<typename RT, typename P1,
typename P2,
typename P3>
class FunctionPtrT<RT,P1,P2,P3,void,void>{ //局部特化：3个参数的情况
public:
enum { NumParams = 3 };
typedef RT (*Type)(P1,P2,P3);
};
template<typename RT, typename P1,
typename P2>
class FunctionPtrT<RT,P1,P2,void,void,void>{ //局部特化：2个参数的情况
public:
enum { NumParams = 2 };
typedef RT (*Type)(P1,P2);
};
template<typename RT, typename P1>
class FunctionPtrT<RT,P1,void,void,void,void>{ //局部特化：1个参数的情况
public:
enum { NumParams = 1 };
typedef RT (*Type)(P1);
};
template<typename RT>
class FunctionPtrT<RT,void,void,void,void,void>{ //局部特化：0个参数的情况
public:
enum { NumParams = 0 };
typedef RT (*Type)();
};
/*
* FunctionPtr<RT,P1,P2,P3,P4,P5>：封装函数指针的仿函数类型
* 使用缺省的void时表示该参数为空
*/
template<typename RT, typename P1 = void,
typename P2 = void,
typename P3 = void,
typename P4 = void,
typename P5 = void>
class FunctionPtr{
private:
//获得相应的函数指针类型
typedef typename FunctionPtrT<RT,P1,P2,P3,P4,P5>::Type FuncPtr;
FuncPtr fptr; //被封装的函数指针
public:
//保存好参数个数及其各个参数类型
enum { NumParams = FunctionPtrT<RT,P1,P2,P3,P4,P5>::NumParams };
typedef RT ReturnT;
typedef P1 Param1T;
typedef P2 Param2T;
typedef P3 Param3T;
typedef P4 Param4T;
typedef P5 Param5T;
FunctionPtr(FuncPtr ptr):fptr(ptr) { //构造函数，创建函数对象，它封装了函数指针
}
// 下面是函数调用
RT operator()() { //0个参数的情况
return fptr();
}
RT operator()(typename ForwardParamT<P1>::Type a1){ //1个参数的情况
return fptr(a1);
}
RT operator()(typename ForwardParamT<P1>::Type a1,
typename ForwardParamT<P2>::Type a2){ //2个参数的情况
return fptr(a1, a2);
}
RT operator()(typename ForwardParamT<P1>::Type a1,
typename ForwardParamT<P2>::Type a2,
typename ForwardParamT<P3>::Type a3){ //3个参数的情况
return fptr(a1, a2, a3);
}
RT operator()(typename ForwardParamT<P1>::Type a1,
typename ForwardParamT<P2>::Type a2,
typename ForwardParamT<P3>::Type a3,
typename ForwardParamT<P4>::Type a4){ //4个参数的情况
return fptr(a1,a2,a3,a4);
}
RT operator()(typename ForwardParamT<P1>::Type a1,
typename ForwardParamT<P2>::Type a2,
typename ForwardParamT<P3>::Type a3,
typename ForwardParamT<P4>::Type a4,
typename ForwardParamT<P5>::Type a5){ //5个参数的情况
return fptr(a1,a2,a3,a4,a5);
}
};
/*
* func_ptr(*fp)：包装函数，用于方便地创建封装了函数指针的函数对象
*/
template<typename RT>
inline FunctionPtr<RT> func_ptr(RT (*fp)()){ //0个参数的情况
return FunctionPtr<RT>(fp);
}
template<typename RT, typename P1>
inline FunctionPtr<RT,P1> func_ptr(RT (*fp)(P1)){ //1个参数的情况
return FunctionPtr<RT,P1>(fp);
}
template<typename RT, typename P1, typename P2>
inline FunctionPtr<RT,P1,P2> func_ptr(RT (*fp)(P1,P2)){ //2个参数的情况
return FunctionPtr<RT,P1,P2>(fp);
}
template<typename RT, typename P1, typename P2, typename P3>
inline FunctionPtr<RT,P1,P2,P3> func_ptr(RT (*fp)(P1,P2,P3)){ //3个参数的情况
return FunctionPtr<RT,P1,P2,P3>(fp);
}
template<typename RT, typename P1, typename P2, typename P3,typename P4>
inline FunctionPtr<RT,P1,P2,P3,P4> func_ptr(RT (*fp)(P1,P2,P3,P4)){ //4个参数的情况
return FunctionPtr<RT,P1,P2,P3,P4>(fp);
}
template<typename RT, typename P1, typename P2, typename P3,typename P4,typename P5>
inline FunctionPtr<RT,P1,P2,P3,P4,P5> func_ptr(RT (*fp)(P1,P2,P3,P4,P5)){ //5个参数的情况
return FunctionPtr<RT,P1,P2,P3,P4,P5>(fp);
}
#endif

测试代码如下：

//functionptrtest.cpp：对封装函数指针的仿函数进行测试
#include <iostream>
#include <string>
#include <typeinfo>
#include "functionptr.hpp"
double seven(){ //0个参数的情况
return 7.0;
}
std::string more(){ //0个参数的情况
return std::string("more");
}
int display(int a,int b){ //2个参数的情况
std::cout<<a<<","<<b<<std::endl;
return 0;
}
int output(int a,double b,std::string c){ //3个参数的情况
std::cout<<a<<","<<b<<","<<c<<std::endl;
return 0;
}
template <typename FunctorT>
void demo(FunctorT func){ //func是封装了函数指针的函数对象，这个函数指针有0个参数
std::cout << "Functor returns type: "
<< typeid(typename FunctorT::ReturnT).name() << '/n'
<< "Functor returns value: "
<< func() << '/n';
}
int main(){
demo(func_ptr(seven));
demo(func_ptr(more));
func_ptr(display)(123,456);
func_ptr(output)(83,3.14159,"Jack Zhou");
return 0;
}

3、仿函数的组合： Composer<FO1,FO2>用来组合两个仿函数的使用，先调用仿函数FO1（其参数个数可以是0-20个），再把其返回的结果的用作实参来调用仿函数FO2。可见FO2只能有一个参数，且与FO1的返回类型相同，这样才能组合使用。包装函数compose(f1,f2)用来方便地创建两个仿函数的组合对象。

//composer.hpp：Composer<FO1,FO2>用于组合两个仿函数的使用
#ifndef COMPOSER_HPP
#define COMPOSER_HPP
#include "forwardparam.hpp"  //用于决定函数的形参T是传引用还是传原来的普通类型
#include "functorparam.hpp"  //用于获取仿函数各个参数的类型
/*
* BaseMem<C,N>：为了避免Composer多次继承同一个类而引入的间接层
*/
template <typename C, int N>
class BaseMem : public C { //直接继承模板参数C（是一个仿函数类）
public:
BaseMem(C& c) : C(c) { }
BaseMem(C const& c) : C(c) { }
};
/*
* Composer<FO1,FO2>：组合两个仿函数FO1、FO2，先调用FO1，再调用FO2
* 通过BaseMem间接继承FO1和FO2，这样当FO1或FO2为空类是就可以进行空基类优化
*/
template <typename FO1, typename FO2>
class Composer : private BaseMem<FO1,1>,
private BaseMem<FO2,2>{
public:
enum { NumParams = FO1::NumParams }; //参数个数
typedef typename FO2::ReturnT ReturnT; //最后的返回类型
//用FunctorParam来获取仿函数FO1的各个参数类型，
//作为Composer的各个参数Param1T, Param2T,...
// 用宏来简化参数类型的定义
#define ComposeParamT(N)      /
typedef typename FunctorParam<FO1, N>::Type Param##N##T;

//假设N到20为止，很少有多于20个参数的仿函数
ComposeParamT(1)
ComposeParamT(2)
ComposeParamT(3)
//...
ComposeParamT(20)
#undef ComposeParamT
//构造函数：组合两个仿函数对象，这里考虑了各种const和非const的情况
//把两个仿函数对象存储在基类子对象中，这就允许进行空基类优化
Composer(FO1 const& f1, FO2 const& f2)
: BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {
}
Composer(FO1 const& f1, FO2& f2)
: BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {
}
Composer(FO1& f1, FO2 const& f2)
: BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {
}
Composer(FO1& f1, FO2& f2)
: BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {
}
//针对0个参数的函数调用
ReturnT operator() (){ //针对0个参数的函数调用
return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()());
}
//针对1个参数的函数调用
ReturnT operator() (typename ForwardParamT<Param1T>::Type v1) {
return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()(v1));
}
//针对2个参数的函数调用
ReturnT operator() (typename ForwardParamT<Param1T>::Type v1,
typename ForwardParamT<Param2T>::Type v2) {
return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()(v1, v2));
}
//针对3个参数的函数调用
ReturnT operator() (typename ForwardParamT<Param1T>::Type v1,
typename ForwardParamT<Param2T>::Type v2,
typename ForwardParamT<Param3T>::Type v3) {
return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()(v1, v2,v3));
}

//...
//一直写到针对20个参数的函数调用
};
/*
* compose(f1,f2)包装函数：用于方便地创建两个仿函数的组合
*/
template <typename FO1, typename FO2>
inline Composer<FO1,FO2> compose(FO1 f1, FO2 f2) {
return Composer<FO1,FO2> (f1, f2);
}
#endif

//composertest.cpp：对仿函数组合的测试
#include <iostream>
#include "composer.hpp"
#include "functionptr.hpp"
double add(double a, double b){
return a+b;
}
double twice(double a){
return 2*a;
}
int main(){
std::cout << "compute (20+7)*2: "
<< compose(func_ptr(add),func_ptr(twice))(20,7)
<< '/n';
return 0;
}

解释：
（1）这里让Composer<FO1,FO2>通过BaseMem间接继承模板参数FO1,FO2，以便当FO1和FO2为空类时可以进行空基类优化。如果Composer直接继承FO1和FO2，当FO1和FO2为同一个类型时，编译会出错，因此我们需要要引入间接层BaseMem，现在的基类BaseMem<FO1,1>和BaseMem<FO2,2>并不是同一个类型。
（2）Composer是仿函数类，需要遵循仿函数的编写约定。它的各个参数类型是FO1的各个参数类型。因此我们需要用FunctorParam来抽取仿函数FO1的各个参数类型，以作为Composer的各个参数Param1T, Param2T,...,Param20T。
（3）构造函数用于组合两个仿函数对象，它需要考虑两个仿函数的const和非const的情况。下面的函数调用运算符中是先调用FO1，把返回结果作为实参再调用FO2。
4、仿函数参数的值绑定： 即将仿函数的某个参数绑定为一个特定的值，这样仿函数的参数就可以减少一个。我们需要开发出一个绑定器（是一个仿函数）来作绑定操作，一个独立的类来存放绑定值。绑定器的各个参数类型萃取也比较麻烦，它需要去掉仿函数中被绑定的参数，然后后面的参数又要前移一个位置，因此我们把绑定器的参数类型萃取抽离出来设计成一个独立的模板。
下面的BoundVal<T>用于在运行期存放T类型的绑定值（这个值后面会被绑定到仿函数的某个参数上去），而StaticBoundVal<T> 则用于在编译期存放T类型的绑定值。

//boundval.hpp：存放绑定值的模板，可通过get()来获取这个绑定值
#ifndef BOUND_VAL_HPP
#define BOUND_VAL_HPP
#include "typeop.hpp"
template <typename T>
class BoundVal{ //在运行期存放T类型的绑定值
private:
T value; //存放绑定值的对象
public:
typedef T ValueT;
BoundVal(T v):value(v){ //把要绑定的值通过构造函数传进来
}
typename TypeOp<T>::RefT get(){ //设置或获取绑定的值
return value;  //返回非const的引用
}
};
template <typename T, T Val>
class StaticBoundVal{ //在编译期存放T类型的绑定值
public:
typedef T ValueT;
T get(){ //通过get()来获取绑定的值
return Val;
}
};
#endif

下面的BinderParams<F,P>用来萃取绑定器的参数类型。它只要去掉仿函数中被绑定的参数， 并把后面的参数前移1个位置即可。

//binderparams.hpp：绑定器的参数类型列表，去掉仿函数中被绑定的参数，
//并把后面的参数前移1个位置即可
#ifndef BINDER_PARAMS_HPP
#define BINDER_PARAMS_HPP
#include "ifthenelse.hpp"
/*
* BinderParams<F,P>：用于将被绑定参数（即第P个参数）后面的参数前移1个位置
* BinderParams<F,P>::ParamNT：仿函数F被绑定后的第N个参数类型
*/
template<typename F, int P>
class BinderParams{
public:
enum { NumParams = F::NumParams-1 };//一个参数已绑定，故参数个数减1

//将被绑定参数（即第P个参数）后面的参数前移1个位置
#define ComposeParamT(N)                                   /
typedef typename IfThenElse<(N<P), FunctorParam<F, N>,     /
FunctorParam<F, N+1>    /
>::ResultT::Type                /
Param##N##T;

//假设N到20为止，很少有多于20个参数的仿函数
ComposeParamT(1)
ComposeParamT(2)
ComposeParamT(3)
//...
ComposeParamT(20)

#undef ComposeParamT
};
#endif

下面的SignSelectT<S,NegT,ZeroT,PosT>根据整数S是正、0、还是负来选择相应的类型。

//signselect.hpp：根据整数S是正、0、还是负来选择相应的类型
#ifndef SIGN_SELECT_HPP
#define SIGN_SELECT_HPP
#include "ifthenelse.hpp"
template <int S, typename NegT, typename ZeroT, typename PosT>
struct SignSelectT{
typedef typename
IfThenElse<(S<0),
NegT,
typename IfThenElse<(S>0),
PosT,
ZeroT
>::ResultT
>::ResultT
ResultT;
};
#endif

下面是真正的绑定器Binder<FO,P,V>。它把仿函数FO的第P个参数绑定为一个存放在V类型对象中的绑定值，绑定后它还要完成对仿函数FO的调用，即Binder<FO,P,V>本身就相当于被绑定后的FO。Binder的参数类型列表Params是仿函数FO去掉绑定参数后的各个参数类型，可见Binder::operator()的参数个数比底层的FO::operator()少一个，因此它在调用底层的FO::operator()时需要重新确定原来FO的参数，并指定一个参数为绑定值。嵌套类模板ArgSelect<A>就是用来确定FO的各个实参。包装函数bind<P>(fo,val)用于方便地将仿函数对象fo的第P个参数绑定为值val。

//binder.hpp：用于对仿函数的参数进行值绑定
#ifndef BINDER_HPP
#define BINDER_HPP
#include "ifthenelse.hpp"
#include "typeop.hpp"
#include "boundval.hpp"     //用于存放要绑定的值
#include "forwardparam.hpp" //用于决定仿函数的形参T是传引用还是传原来的普通类型
#include "functorparam.hpp" //获取仿函数各个参数的类
#include "binderparams.hpp" //用于将被绑定参数后面的参数前移1个位置
#include "signselect.hpp"   //根据整数的正负性来选择相应的类型
/*
* Binder<FO,P,V>：把仿函数FO的第P个参数绑定为一个存放在V类型对象中的绑定值，
* V是BoundVal<T>或StaticBoundVal<T,val>类型，里面存放了真正
* 的绑定值（是T类型的）
*/
template <typename FO, int P, typename V>
class Binder : private FO, private V{
public:
enum { NumParams = FO::NumParams-1 }; //一个参数已经绑定，故参数个数减1
typedef typename FO::ReturnT ReturnT; //返回类型
typedef BinderParams<FO, P> Params; //参数类型列表：Params中含有仿函数FO
//去掉绑定参数后的各个参数类型

//定义Binder需要的各个参数类型（或者为原来类型的const引用，或者为原来的普通类型）
#define ComposeParamT(N)                                           /
typedef typename ForwardParamT<typename Params::Param##N##T>::Type /
Param##N##T;
ComposeParamT(1)
ComposeParamT(2)
ComposeParamT(3)
//...
ComposeParamT(20)

#undef ComposeParamT
//构造函数：根据传过来的仿函数对象和存放了绑定值的V类型对象构造Binder，
//这里考虑了各种const和非const的情况
Binder(FO& f): FO(f) {}
Binder(FO& f, V& v): FO(f), V(v) {}
Binder(FO& f, V const& v): FO(f), V(v) {}
Binder(FO const& f): FO(f) {}
Binder(FO const& f, V& v): FO(f), V(v) {}
Binder(FO const& f, V const& v): FO(f), V(v) {}

//构造函数模板：直接根据仿函数对象和要绑定的值（T类型的）构造Binder，绑定的值存储在
//BoundVal<T>中，即在运行期存储绑定值
template<class T>
Binder(FO& f, T& v): FO(f), V(BoundVal<T>(v)) {}

template<class T>
Binder(FO& f, T const& v): FO(f), V(BoundVal<T const>(v)) {}
//函数调用：对调用实参个数不同的情况，都要重载调用运算符
//Binder::operator()的参数个数比底层的FO::operator()少一个
ReturnT operator()(){
return FO::operator()(V::get());
}
ReturnT operator()(Param1T v1){
//根据实参位置（1和2）与P的相对位置，用from函数自动选择是使用用户
//提供的v1，还是使用被绑定的值V::get()
return FO::operator()(ArgSelect<1>::from(v1,v1,V::get()),
ArgSelect<2>::from(v1,v1,V::get()));
}
ReturnT operator()(Param1T v1, Param2T v2){
return FO::operator()(ArgSelect<1>::from(v1,v1,V::get()),
ArgSelect<2>::from(v1,v2,V::get()),
ArgSelect<3>::from(v2,v2,V::get()));
}
ReturnT operator()(Param1T v1, Param2T v2, Param3T v3) {
return FO::operator()(ArgSelect<1>::from(v1,v1,V::get()),
ArgSelect<2>::from(v1,v2,V::get()),
ArgSelect<3>::from(v2,v3,V::get()),
ArgSelect<4>::from(v3,v3,V::get()));
}
//...
//一直写到针对20个参数的函数调用
private:
template<int A>
class ArgSelect{ //私有的嵌套类模板：实参选择器，用来确定FO原来的各个实参
public:
//定义绑定实参前面的类型：FO的第A个参数类型ArgSelect<A>::NoSkipT恰为
//Binder的第A个参数类型（取其引用类型），当A达到比NumParams多1时，退回到Binder的A-1处
typedef typename TypeOp<
typename IfThenElse<(A<=Params::NumParams),
FunctorParam<Params, A>,
FunctorParam<Params, A-1>
>::ResultT::Type>::RefT
NoSkipT;

//定义绑定实参后面的类型：FO的第A个参数类型ArgSelect<A>::SkipT恰为
//Binder的第A-1个参数类型（取其引用类型），当A为1时，前移到Bindder的A处
//ArgSelect<A>::NoSkipT
typedef typename TypeOp<
typename IfThenElse<(A>1),
FunctorParam<Params, A-1>,
FunctorParam<Params, A>
>::ResultT::Type>::RefT
SkipT;

//定义绑定实参处的类型：在存放绑定值的V类型中有记录
typedef typename TypeOp<typename V::ValueT>::RefT BindT;
//3个不同的嵌套类，用来实现3种情况下FO实参值的选择
class NoSkip{ //选择绑定参数前面的实参：为用户指定的实参
public:
static NoSkipT select(SkipT prev_arg, NoSkipT arg,
BindT bound_val) {
return arg;
}
};
class Skip{ //选择绑定参数后面的实参：为用户指定的实参
public:
static SkipT select(SkipT prev_arg, NoSkipT arg,
BindT bound_val){
return prev_arg;
}
};
class Bind{ //选择绑定参数处的实参：为绑定值
public:
static BindT select(SkipT prev_arg, NoSkipT arg,
BindT bound_val){
return bound_val;
}
};
//根据A与P的相对位置返回仿函数FO中A处的参数类型
typedef typename SignSelectT<A-P, NoSkipT,
BindT, SkipT>::ResultT
ReturnT;

//根据A与P的相对位置返回仿函数FO的实参选择类（上面的3个嵌套类之一，用来
//选择FO在A处的实参值）
typedef typename SignSelectT<A-P, NoSkip,
Bind, Skip>::ResultT
SelectedT;

//实际的选择函数：
static ReturnT from (SkipT prev_arg, NoSkipT arg,
BindT bound_val){
//根据获得的选择类，调用select来选择相应的实参值
return SelectedT::select(prev_arg, arg, bound_val);
}
};
};
/*
* 包装函数bind<P>(fo,val)：将仿函数对象fo的第P个参数绑定为值val
* FO可演绎出来，FunctorParam<FO,P>::Type为绑定值的类型
* BoundVal<typename FunctorParam<FO,P>::Type>为存放绑定值的V类型
* ForwardParamT可用来决定val是传引用还是传原来的类型
*/
template <int P,typename FO>     //P为绑定参数的位置，FO为仿函数
inline Binder<FO,P,BoundVal<typename FunctorParam<FO,P>::Type> >
bind(FO const& fo,
typename ForwardParamT<typename FunctorParam<FO,P>::Type>::Type val){
//返回一个对fo进行绑定后的Binder仿函数对象
return Binder<FO,
P,
BoundVal<typename FunctorParam<FO,P>::Type>
>(fo,BoundVal<typename FunctorParam<FO,P>::Type>(val));
}
#endif

解释：
（1）Binder继承自模板参数FO和V，这样就可以使用空基类优化技术。Binder是一个仿函数，因此它要遵循仿函数的编写约定，定义参数个数和各个参数类型（用上面的BinderParams来萃取）。
（2）构造函数根据传过来的仿函数对象和存放了绑定值的V类型对象构造Binder，它需要考虑各种const和非const的情况。而构造函数模板则直接根据仿函数对象和要绑定的值（T类型的）构造Binder，绑定的值存储在BoundVal<T>中，即在运行期存储绑定值。
（3）ArgSelect<A>用来确定原来FO的各个实参，这样才能在Binder中完成对被绑定的FO的调用。它先根据A的位置定义绑定实参前面的类型NoSkipT、绑定实参后面的类型SkipT、以及绑定实参处的类型BindT。然后定义3个不同的嵌套类，里面有一个静态的select函数，用来实现3种情况下对FO实参值的选择。接着根据A与P的相对位置，用SignSelectT得到仿函数FO中A处的参数类型、以及仿函数FO的实参选择类（即上面的的3个嵌套类之一）。最后是真正的实参选择函数from，它调用相应选择类的select，根据实参位置A与P的相对位置，自动选择FO中A处是使用用户提供的实参，还是使用被绑定的值。
（4）函数调用Binder::operator()对调用实参个数不同的情况，都要进行重载。Binder::operator()直接调用FO::operator()，而各个实参是根据所在位置用ArgSelect<n>::from来自动选择，对FO中绑定处的参数用绑值V::get()，对其他位置的参数则用用户传递过来的实参。
（5）包装函数bind<P>(fo,val)直接返回一个对fo绑定后的少了一个参数的仿函数对象。它的使用就相当于对少了一个参数的fo的使用。
测试代码如下：

//bindertest.cpp：对绑定器Binder的测试
#include <string>
#include <iostream>
#include "functionptr.hpp"
#include "binder.hpp"
//这个函数会被func_ptr封装为仿函数
bool func(std::string const& str, double d, float f){
std::cout << str << ": "
<< d << (d<f? "<": ">=")
<< f << '/n';
return d<f;
}
int main(){
//把仿函数func_ptr(func)的第1个参数绑定为"Comparing"
bool result = bind<1>(func_ptr(func), "Comparing")(1.0, 2.0);
std::cout << "bound function returned " << result << '/n';
return 0;
}

5、普通函数参数的值绑定： 可先用上面的func_ptr(*fp)把函数（最多只能接受5个参数）封装成仿函数，再用bind来进行值绑定即可。上面的测试代码中就是这样用的。从中我们可以看出，通过使用func_ptr和bind的实现，我们可以对任意普通函数的参数进行值绑定。