绑定器

比眉伴天荒 2022-08-09 12:44 157阅读 0赞

使用STL的过程中，有时适当地使用绑定器，能够使得代码更简洁、更高效。谈到绑定器，就不得不说说函数对象（function object），或称为仿函数（functor）。

C++中的函数对象是这样一种特殊的类型，它定义了操作符“()”，所以能够像函数调用一样在对象名后加上“()”，并传入对应的参数，从而执行相应的功能。这样的类型就是函数对象，STL中通常使用函数对象作为容器的排序规则并且在算法中广泛应用。如下面定义的类就是一个简单的函数对象：

**\[csharp\]**  [view plain][] [copy][view plain]

1.  **class** Functor  
2.    
3.  \{  
4.    
5.  **public**:  
6.    
7.      **int** **operator**()(**int** a, **int** b)  
8.    
9.      \{  
10.   
11.         **return** a < b;  
12.   
13.     \}  
14.   
15. \};  
16.   
17.   
18.   
19. **int** main()  
20.   
21. \{  
22.   
23.     Functor f;  
24.   
25.     **int** a = 5;  
26.   
27.     **int** b = 7;  
28.   
29.     **int** ans = f(a, b);  
30.   
31. \}

STL中的绑定器有类绑定器和函数绑定器两种，类绑定器有binder1st和binder2nd，而函数绑定器是bind1st和bind2nd。下面是STL在vs2008中的实现，可以看到类绑定器binder2nd是从模板类unary\_function继承而来的，所以从根本上说它是一个一元函数对象，同理binder1st亦然。而bind2nd是一个全局的模板函数其返回值为一个binder2nd模板类的实例。所以本质上无论类绑定器还是函数绑定器都是用于构造一个一元的函数对象。

**\[csharp\]**  [view plain][] [copy][view plain]

1.  template<**class** \_Fn2>  
2.    
3.  **class** binder2nd : **public** unary\_function<typename \_Fn2::first\_argument\_type,  
4.    
5.              typename \_Fn2::result\_type>  
6.    
7.  \{   // functor adapter \_Func(left, stored)  
8.    
9.  **public**:  
10.   
11.     typedef unary\_function<typename \_Fn2::first\_argument\_type,  
12.   
13.         typename \_Fn2::result\_type> \_Base;  
14.   
15.     typedef typename \_Base::argument\_type argument\_type;  
16.   
17.     typedef typename \_Base::result\_type result\_type;  
18.   
19.   
20.   
21.     binder2nd(**const** \_Fn2& \_Func,  
22.   
23.         **const** typename \_Fn2::second\_argument\_type& \_Right)  
24.   
25.         : op(\_Func), value(\_Right)  
26.   
27.     \{   // construct from functor and right operand  
28.   
29.     \}  
30.   
31.   
32.   
33.     result\_type **operator**()(**const** argument\_type& \_Left) **const**  
34.   
35.     \{   // apply functor to operands  
36.   
37.         **return** (op(\_Left, value));  
38.   
39.     \}  
40.   
41.   
42.   
43.     result\_type **operator**()(argument\_type& \_Left) **const**  
44.   
45.     \{   // apply functor to operands  
46.   
47.         **return** (op(\_Left, value));  
48.   
49.     \}  
50.   
51.   
52.   
53. **protected**:  
54.   
55.     \_Fn2 op;    // the functor to apply  
56.   
57.     typename \_Fn2::second\_argument\_type value;  // the right operand  
58.   
59. \};

**\[csharp\]**  [view plain][] [copy][view plain]

1.  // TEMPLATE FUNCTION bind2nd  
2.    
3.  template<**class** \_Fn2,  
4.    
5.      **class** \_Ty> inline  
6.    
7.  binder2nd<\_Fn2> bind2nd(**const** \_Fn2& \_Func, **const** \_Ty& \_Right)  
8.    
9.  \{   // return a binder2nd functor adapter  
10.   
11.     typename \_Fn2::second\_argument\_type \_Val(\_Right);  
12.   
13.     **return** (std::binder2nd<\_Fn2>(\_Func, \_Val));  
14.   
15. \}

那么到底什么是绑定器呢？它有什么具体的用途？MSDN中对绑定器的解释是：“an adaptor to convert a binary function object into a unary function object by binding the first/second argument of the binary function to a specified value”，意思是绑定器是一种适配器，用于将二元函数对象的第一或者第二个参数绑定为一个特定的值的方式来实现二元函数对象向一元函数对象的转换。所以，绑定器的实质是一个函数适配器，它能够实现将二元函数对象转换为一元函数对象。在很多STL的算法函数中，需要给某个参数传入一个一元的函数对象，但有些时候由于实际的需要，直接定义一个一元函数对象并不是很直观有效，此时应用绑定器或许会有意外的收获。

下面的例子给出了一个可能应用到绑定器的实际情境。在一个序列容器，如vector或者list中，存储着结构体或者类的实例对象，或者是它的指针形式，现在的需求是，需要在这样的序列容器中快速找出结构体或者类这样的复合类型对象中的某个成员的值满足一定条件的某个对象或其指针的值。

让我们先来看看函数find\_if的原型，可以看到前两个参数是输入迭代器，表明了查找的区间，第三个参数则是一个一元谓词。所谓谓词即是一种特殊的函数对象，它的返回值始终为bool类型，对应于函数对象便有一元谓词和二元谓词之分。对于find\_if来说，一元谓词的唯一参数其类型必须是序列容器中元素的类型。

**\[csharp\]**  [view plain][] [copy][view plain]

1.  template<**class** InputIterator, **class** T, **class** Predicate> inline  
2.    
3.     InputIterator find\_if(  
4.    
5.        InputIterator First,  
6.    
7.        InputIterator Last,  
8.    
9.        Predicate Predicate  
10.   
11.    )

类似的其他函数如count\_if、remove\_if等都需要这样的谓词，通常利用这些函数的自定义谓词版本来快速查找序列容器中符合条件的元素时，代码可以写得很elegant。

**\[csharp\]**  [view plain][] [copy][view plain]

1.  **bool** IsObjEquals(**int** n)  
2.    
3.  \{  
4.    
5.     **if** (n%2) **return** **true**;  
6.    
7.  \}  
8.    
9.    
10.   
11. remove\_if(MyList.begin(), MyList.end(), IsObjEquals());

然而，当需要在复合类型对象中找出某个满足条件的元素，其某个成员值满足相应的条件时，单纯的定义一个一元谓词是无能为力的。此时一元的函数对象难以表达复合对象和目标类型之间的关系，想像中可以定义类似于如下这样的二元函数对象（二元谓词）来实现。

**\[csharp\]**  [view plain][] [copy][view plain]

1.  **struct** IsObjIDEquals : binary\_function<COMPOSEOBJ, **int**, **bool**>   
2.    
3.  \{  
4.    
5.      **bool** **operator**()(**const** COMPOSEOBJ &\_left, **int** \_right) **const**  
6.    
7.      \{  
8.    
9.            **if** (\_left.nID == \_right)  
10.   
11.           \{  
12.   
13.                   **return** **true**;  
14.   
15.           \}  
16.   
17.           **else**  
18.   
19.           \{  
20.   
21.                   **return** **false**;  
22.   
23.           \}  
24.   
25.     \}  
26.   
27. \};

但是，事情并不是这么简单，find\_if等函数只接受一元谓词，而且需要查找的复合类型中某个成员的值在一次运算（查找、计数或者删除等）过程中是恒定的。如何将这样的二元谓词转换为一元谓词呢？绑定器此时可以发挥它的威力了。当在一次查找（find\_if）、计数（count\_if）或删除（remove\_if）操作中，复合类型中的单个成员值总是相对恒定的，所以可以利用bind2nd通过绑定二元函数对象中的第二个参数的方式来实现二元谓词向一元谓词的转换。于是运算的代码可以如下例这样写，同样很elegant。

**\[csharp\]**  [view plain][] [copy][view plain]

1.  remove\_if(MyList.begin(), MyList.end(),bind2nd(IsObjIDEquals(), 3));  
2.  //STL示例 绑定器函数对象bind1st  
    \#include <iostream>  
    \#include <algorithm>  
    \#include <functional>  
    \#include <list>  
    using namespace std;  
      
      
    int iarray\[10\] = \{1, 2, 3, 4, 5, 6, 7, 8, 9, 10\};  
    list<int> aList(iarray, iarray + 10);  
      
      
    int main()  
    \{  
    int k = 0;  
    //count\_if统计满足条件的元素个数  
    /\*其中greater()实现如下  
    template<class T>  
        struct greater : public binary\_function<T, T, bool> \{  
        bool operator()(const T& x, const T& y) const   
    \{return (x>y);\};  
        \};  
    bind1st函数作用是将8绑定到greater的第一个参数上,看上面greater类型定义及实现  
    可以知道这里是求小于8的元素\*/  
    k=count\_if(aList.begin(), aList.end(),bind1st(greater<int>(),8));  
    cout << "小于8的数的个数 ：" << k << endl;  
    return 0;  
    \}  
    
3.  前面在[“STL中绑定器的使用”][STL] 一文中已经初步阐述了使用STL中的绑定器和函数对象实现对序列容器中的数据进行排序或者查找的方法，使用此方法能够写出优雅高效的代码。本文在原先的基础上作进一步的延伸，通过一个实际问题的使用情景，介绍使用“绑定器和函数对象嵌套调用”的方法在最少代码的基础上实现高效的功能。
    
     
    
          问题：有一组电池，需要对其根据各自的参数和指标信息进行分组。参数和指标信息即是指电池的电压和放电时间，分组的基本思想是**将彼此之间的的电压误差和放电时间误差分别在某个容许值范围内的电池归为一组** 。
    
     
    
          例如，有这样一组电池，每个电池均有唯一的编号，每个电池的电压值和放电时间均已测定，现在要讲这些电池按每三个一组来分类，每组中两两之间的电压误差不大于0.02，放电时间误差不大于1。
    
     
    
          分析：这个问题的算法并不复杂，一般的处理思路就是先开一个数组或者链表存放组的信息，然后遍历每个电池，确定这个电池可以分配到已经存在的各个组中的哪一个，如果找到可以分配的组，则将电池分配到这个组中，同时开始下一个，否则，则新增一个组，并插入其中，并继续处理下一个电池。
    
     
    
          如果我们不使用STL，而直接用C代码或者C++代码来书写，那么代码难免会显得冗长，抛开其他不谈，单单for循环都得有好几个，这其中还不考虑由于多方面的原因而带来的效率降低问题。而借助于STL中的绑定器和函数对象，我们可以用更简洁更优雅的代码来实现这个处理逻辑。
    
     
    
         “ 源代码就是设计”，直接看代码。
    
     
    
         先定义电池信息的基本结构，以及其他一些数据结构。
    
     
    
    **\[cpp\]**  [view plain][view plain 1] [copy][view plain 1]
    
    1.  // 电池信息结构  
    2.  **struct** BATTERY\_INFO  
    3.  \{  
    4.      unsigned **int**    Code;   // 序号  
    5.      **double**      Voltage;// 电压值  
    6.      **double**      DischargeTime;  // 放电时间  
    7.  \};  
    8.  **typedef** vector<BATTERY\_INFO> BATTERYINFOARRAY;  
    9.  BATTERYINFOARRAY vecBatteryInfo;        // 电池信息数组  
    10. vector<BATTERYINFOARRAY> vecGroups;   // 分组信息数组  
    11. **double** dblVoltageErrLimit = 0.02;   // 电压误差限值  
    12. **double** dblTimeErrLimit = 1;     // 放电时间误差限值  
    13. unsigned **int** nMaxLimit = 3;     // 每组的最大电池数  
    
     
    
    判断组是否可用的二元函数对象**IsGroupAvailable **的实现：在重载其“()”操作符时，用find\_if在组中查找是否超限的情况存在，如果找到超限的，则find\_if的返回值即不等于end，注意在这里嵌套调用了另一个二元函数对象**IsLimitExceed **来判断是否超限。
    
    **\[cpp\]**  [view plain][view plain 1] [copy][view plain 1]
    
    1.  **struct** IsGroupAvailable : **public** binary\_function<BATTERYINFOARRAY, pair<**double**, **double**>, **bool**>  
    2.  \{  
    3.      **bool** operator ()(BATTERYINFOARRAY &\_left, pair<**double**, **double**> \_right) **const**  
    4.      \{  
    5.          BATTERYINFOARRAY::iterator itr;  
    6.          itr = find\_if(\_left.begin(), \_left.end(), bind2nd(IsLimitExceed(), \_right));  
    7.          **return** itr==\_left.end() && \_left.size()<=nMaxLimit-1;  
    8.      \}  
    9.  \};  
    
     
    
    二元函数对象IsLimitExceed的实现如下：
    
    **\[cpp\]**  [view plain][view plain 1] [copy][view plain 1]
    
    1.  **struct** IsLimitExceed : **public** binary\_function<BATTERY\_INFO, pair<**double**, **double**>, **bool**>  
    2.  \{  
    3.      **bool** operator ()(BATTERY\_INFO &\_left, pair<**double**, **double**> \_right) **const**  
    4.      \{  
    5.          **if** (fabs(\_left.Voltage-\_right.first)>dblVoltageErrLimit ||  
    6.              fabs(\_left.DischargeTime-\_right.second)>dblTimeErrLimit)  
    7.          \{  
    8.              **return** **true**;  
    9.          \}  
    10.         **else**  
    11.         \{  
    12.             **return** **false**;  
    13.         \}  
    14.     \}  
    15. \};  
    
     
    
          有了判断当前电池信息是否可以分配到某个组中的关键代码，以及判断分组是否可用的代码，那么剩下的问题就很显而易见了，下面是自动分组的函数代码，其调用find\_if，并传入应用了绑定器之后的函数对象IsGroupAvailable。
    
     
    
    **\[cpp\]**  [view plain][view plain 1] [copy][view plain 1]
    
    1.  // 自动分组  
    2.  **void** AutoGrouping()  
    3.  \{  
    4.      BATTERYINFOARRAY::iterator itrInfo;  
    5.      vector<BATTERYINFOARRAY>::iterator itrGroup;  
    6.      **for** (itrInfo=vecBatteryInfo.begin(); itrInfo!=vecBatteryInfo.end(); ++itrInfo)  
    7.      \{  
    8.          // 对每个电池，到组信息中查找，找出能够插入的组的迭代器  
    9.          itrGroup = find\_if(vecGroups.begin(), vecGroups.end(), bind2nd(IsGroupAvailable(),  
    10.             make\_pair((\*itrInfo).Voltage, (\*itrInfo).DischargeTime)));  
    11.         // 如果没找到，则新增一个组  
    12.         **if** (itrGroup == vecGroups.end())  
    13.         \{  
    14.             BATTERYINFOARRAY \_array;  
    15.             \_array.push\_back(\*itrInfo);  
    16.             vecGroups.push\_back(\_array);  
    17.         \}  
    18.         **else**  
    19.         \{  
    20.             // 增加到找到的组中  
    21.             (\*itrGroup).push\_back(\*itrInfo);  
    22.         \}  
    23.     \}  
    24. \}  
    
     
    
          这样，整个逻辑的处理流程就已经完毕。可以看到，采用绑定器结合嵌套的函数对象调用的方式，写出来的代码更优雅。同时由于使用了标准的STL算法函数，还可以借助于编译器的优化来提高程序的性能

[view plain]: http://blog.csdn.net/zhouzhenyan/article/details/2617600#
[STL]: http://blog.csdn.net/zhouzhenyan/archive/2008/07/06/2617600.aspx
[view plain 1]: http://blog.csdn.net/zhouzhenyan/article/details/4500371#