STL函数对象及函数对象适配器

一 函数对象Functor

STL中提供了一元和二元函数的两种Functor,通过unary_function和binary_function提供了这两种不同参数数量的 Functor的基本结构,在这两个类型中,分别内嵌定义一元和二元函数操作在模版推演的时候需要用到的typedef.
 //一元函数的定义为
template<class _A, class _R>
struct unary_function {
 typedef _A argument_type;
 typedef _R result_type;
};

//二元函数的定义为
template<class _A1, class _A2, class _R>
 struct binary_function {
 typedef _A1 first_argument_type;
 typedef _A2 second_argument_type;
 typedef _R result_type;
};

其他的一元和二元Functor可以从这两个基本结构继承,同时也就可以推演出函数的参数和返回值的类型,STL在上述这两个结构的基础上,实现了很多一元和二元的Functor.

//一元
negate

//二元
plus
minus
multiplies
divides
modulus
equal_to
not_equal_to
greater
greater_equal
less
less_equal
logical_and
logical_or
logical_not

上面的这些Functor都是基于模版实现的,可以象下面那样使用的方式:

plus<int> int_plus;
cout << int_plus(111,222) << endl;

 

二 函数对象适配器

函数对象适配器的作用就是使函数转化为函数对象，或是将多参数的函数对象转化为少参数的函数对象。

1）bind

bind1st  //通过绑定第一个参数，使二元的函数对象转化为一元的函数对象
bind2nd  //通过绑定第二个参数，使二元的函数对象转化为一元的函数对象
not1     //对一元的函数对象取反
not2     //对二元的函数对象取反

使用的方式:
bind1st( less<int>(), 10)(20);
not2( less<int() )(10,20);

这些Functor看起来好像好像用处不大,但是在和STL中的容器和算法结合在一起使用的时候,就会使得程序显得很简洁.

int i;   
vector<int> lv;
for(i = 0; i < 100; i++)
{
    lv.push_back(i);
}
//对vector中小于20的数进行记数
cout << count_if(lv.begin(), lv.end(), bind2nd(less<int>(), 20)) << endl;

//由大到小排序
sort(lv.begin(), lv.end(), not2(less<int>()) ) ;
for (i = 0; i < 100; i++)
{
    cout << lv.at(i) << endl;
}

2）ptr_fun

ptr_fun是指将现有的函数转换为Functor的功能.在STL中提供了这个功能的Functor,就是pointer_to_unary_function和pointer_to_binary_function这两个类,这两个类对应一元

和二元两种函数,也就是说,对于调用参数为3个或者多于3个的函数,STL提供的Functor类,无法配接.

基本使用方法:

int u_func(int a)
{
    int ret = a;
    return ret;
}   

int b_func(int a,int b)
{
    return a+b;
}

void call()
{
 pointer_to_unary_function<int,int> uf(u_func);
    cout << uf(100) << endl;
   
    pointer_to_binary_function<int,int,int> bf(b_func);
    cout << bf(111,222) << endl;

 //或者
 cout << ptr_fun(u_func)(100) << endl;
    cout << ptr_fun(b_func)(111,222) << endl;

}
可以看到,上面的方法改进了原先C和C++中通过函数指针来间接调用函数的方法,将函数指针封装到了类中.

问题:

第一部分中的Functor中是自己定义操作符(),但是在ptr_fun中,是将已经有的function转为Functor调用就会存在一个调用方式的问题.

c++中的函数,按调用方式可以分为__cdecl, __stdcall,__fastcall 三种,ptr_fun如何正确的识别给定的function的调用方式就会有问题.

其中:
vc6中的STL的ptr_fun代码中,统一将function认为是__cdecl调用方式. 而Dev-cpp中使用的SGI的代码中没有明确指明函数的调用方式,所以将使用编译器的确省设置.
但是如果将上面的b_func函数改为
int __stdcall b_func(int a,int b)
{
    return a+b;
}
上面的使用代码在DEV-CPP中无法编译通过.

3）mem_fun

mem_fun是将某个类中的成员函数转变为Functor的功能.

一般的使用方法
struct mem_fun_struct
{
    int n_mem_fun() {
        cout << "mem_fun_struct::n_mem_fun()" << endl;
        return 0;
    }   
   
    int u_mem_fun(int a) {
        cout << "mem_fun_struct::u_mem_fun(int) " << a << endl;
        return a;
    }   
   
    int b_mem_fun(int a,int b) {
        cout << "mem_fun_struct::b_mem_fun(int,int)" << a << " " << b << endl;
        return a+b;
    }   
};

void call()
{
 mem_fun_struct ls;
    mem_fun(&mem_fun_struct::n_mem_fun)(&ls);
    mem_fun(&mem_fun_struct::u_mem_fun)(&ls, 10);
    //mem_fun(&mem_fun_struct::u_mem_fun)(&ls, 10, 20);
}

上面的代码在dev-cpp 4.9.9中编译通过,SGI STL中没有提供二元成员函数的mem_fun，vc6中提供了mem_fun(无参数成员函数)和mem_fun1(一元参数成员函数), 而在vs2003中改变了用法.但是我看MSDN好像也只支持到一个参数.

三 总结

STL中提供了基本的一元和二元参数的Functor, 同时提供了相应的适配器可以对Functor进行修饰,Functor可以很好的和 STL容器,STL算法结合使用.

但是仍有问题：
1）上面说到的调用方式
2） 多参数函数对象适配

对于我们比较复杂的stl不能满足要求的问题，我们可以是用boost或loki来解决。
  定义了调用操作符的类，其对象常称作函数对象（function object），即它们的行为表现出类似于函数的行为。

    函数对象通常用作泛型算法的实参，如标准库中大量泛型算法有需要函数对象的版本。函数对象使用起来可以比函数灵活。标准库在头文件<functional>头文件中定义了一组算术、关系与逻辑函数对象类，还定义了一组函数适配器，使我们能够特化或者扩展标准库所定义的以及自定义的函数对象类。

每个标准库函数对象类表示一个操作符，即，每个类都定义了应用命名操作的调用操作符。上面只有两个一元函数对象（unary function-object）：negate<Type>和<logical_not<Type>，其它都是二元函数对象（binary function-object）。

 

   函数对象常用于覆盖算法中使用的默认操作符。在使用标准库的函数对象时，需要生成该模板类的一个实例对象，然后将生成的函数对象传递给算法。例如，sort默认使用operator<按升序对容器进行排序。为了按降序对容器进行排序，可以传递函数对象greater：

   sort (svec.begin(), svec.end(), greater<string>());

其中，greater<string>()表示生成一个比较元素类型为string类的greater函数对象。

 

   标准库提供了一组函数适配器（function adapter），用于特化和扩展一元和二元函数对象。函数适配器分为如下两类：

   1）绑定器（binder）：它通过将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象。

   2）求反器（negator）：它将谓词函数对象的真值求反。

 

   标准库定义了两个绑定器适配器：bind1st和bind2nd。每个绑定器接受一个函数对象和一个值。bind1st将给定值绑定到二元函数对象的第一个实参，bind2nd将给定值绑定到二元函数对象的第二个实参。例如，为了计算一个容器中所有小于或等于10的元素的个数，可以这样给count_if 传递值：

   count_if (vec.begin(), vec.end(), bind2nd(less_equal<int>(), 10));

 

   标准库还定义了两个求反器：not1和not2。not1将一元函数对象的真值求反，not2将二元函数对象的真值求反。例如：

   count_if (vec.begin(), vec.end(), not1(bind2nd(less_equal<int>(), 10)));

其效果是对不<=10的那些元素计数，即对>10的元素计数。

算术函数对象类型	plus<Type>	+
	minus<Type>	-
	multiplies<Type>	*
	divides<Type>	/
	modulus<Type>	%
	negate<Type>	-
关系函数对象类型	equal_to<Type>	==
	not_equal_to<Type>	!=
	greater<Type>	>
	greater_equal<Type>	>=
	less<Type>	<
	less_equal<Type>	<=
逻辑函数对象类型	logical_and<Type>	&&
	logical_or<Type>	||
	logical_not<Type>	!