STL中的约束器相关总结

摘要: STL里有仿函数的概念，而在应用仿函数的时候，仿函数与仿函数之间的适配引出了约束器的概念。这一节主要叙述一下一元函数对象基类unary_function、二元函数对象基类binary_function，以及两个约束器binder1st与binder2nd，同时给出一个场景，分析实现原理。

1：template <class Arg, class Result> struct unary_function;

2：template <class Arg1, class Arg2, class Result> struct binary_function;

3: template <class Operation> class binder1st;

4: template <class Operation> class binder2nd;

5: template <class Operation, class T>

     binder2nd<Operation> bind2nd (const Operation& op, const T& x);

6: template <class Operation, class T>

          binder1st<Operation> bind1st (const Operation& op, const T& x);

        unary_function是一元函数对象的基类，unary_function作为一个基类并没有实现operator()，仅仅含有两个数据成员，operator()是由子类根据具体情况实现的。binary_function则是二元函数对象的基类，同样没有实现operator().

template <class Arg, class Result> 
struct unary_function { 
    typedef Arg argument_type; 
    typedef Result result_type; 
}; 
// unary_function example 
#include <iostream> 
#include <functional> 
using namespace std; 
struct IsOdd : public unary_function<int,bool> { 
    bool operator() (int number) {return (number%2==1);} 
}; 
int main () { 
    IsOdd IsOdd_object; 
    IsOdd::argument_type input; 
    IsOdd::result_type result; 
    cout << "Please enter a number: "; 
    cin >> input; 
    result = IsOdd_object (input); 
    cout << "Number " << input << " is " << (result?"odd":"even") << ".\n"; 
    return 0; 
}

template <class Arg1, class Arg2, class Result> 
struct binary_function { 
    typedef Arg1 first_argument_type; 
    typedef Arg2 second_argument_type; 
    typedef Result result_type; 
}; 
// binary_function example 
#include <iostream> 
#include <functional> 
using namespace std; 
struct Compare : public binary_function<int,int,bool> { 
    bool operator() (int a, int b) {return (a==b);} 
}; 
int main () { 
    Compare Compare_object; 
    Compare::first_argument_type input1; 
    Compare::second_argument_type input2; 
    Compare::result_type result; 
    cout << "Please enter first number: "; 
    cin >> input1; 
    cout << "Please enter second number: "; 
    cin >> input2; 
    result = Compare_object (input1,input2); 
    cout << "Numbers " << input1 << " and " << input2; 
    if (result) 
        cout << " are equal.\n"; 
    else 
        cout << " are not equal.\n"; 
    return 0; 
}

binder1st 与 binder2nd 的作用都是由二元函数对象得到一个一元函数对象，他们是"函数对象的适配器"，其中binder1st 将第一个参数固定为一个固定的数值，binder2nd 将第二个参数固定为一个固定的数值。具体使用的时候，将某一个参数绑定为操作的第一个或者第二个参数，要根据操作语义而定，见如下示例。而bind2nd 与bind1st就是为了产生这两种对象而存在的。

template <class Operation> class binder1st 
: public unary_function <typename Operation::second_argument_type, 
typename Operation::result_type> 
{ 
protected: 
    Operation op; 
    typename Operation::first_argument_type value; 
public: 
    binder1st ( const Operation& x, 
        const typename Operation::first_argument_type& y) : op (x), value(y) {} 
    typename Operation::result_type 
        operator() (const typename Operation::second_argument_type& x) const 
    { return op(value,x); } 
}; 
// binder1st example 
#include <iostream> 
#include <functional> 
#include <algorithm> 
using namespace std; 
int main () { 
    binder1st < equal_to<int> > equal_to_10 (equal_to<int>(),10);  // 这里将10版定位(equal_to<int>())操作的第一个参数 
    int numbers[] = {10,20,30,40,50,10}; 
    int cx; 
    cx = count_if (numbers,numbers+6,equal_to_10); 
    cout << "There are " << cx << " elements equal to 10.\n"; 
    return 0; 
}

template <class Operation> class binder2nd 
: public unary_function <typename Operation::first_argument_type, 
typename Operation::result_type> 
{ 
protected: 
    Operation op; 
    typename Operation::second_argument_type value; 
public: 
    binder2nd ( const Operation& x, 
        const typename Operation::second_argument_type& y) : op (x), value(y) {} 
    typename Operation::result_type 
        operator() (const typename Operation::first_argument_type& x) const 
    { return op(x,value); } 
}; 
// binder2nd example 
#include <iostream> 
#include <functional> 
#include <algorithm> 
using namespace std; 
int main () { 
    binder2nd < less<int> > IsNegative (less<int>(),0); // 这里将0绑定为(less<int>())操作的第二个参数 
    int numbers[] = {10,-20,-30,40,-50}; 
    int cx; 
    cx = count_if (numbers,numbers+5,IsNegative); 
    cout << "There are " << cx << " negative elements.\n"; 
    return 0; 
}

下面给出一个场景分析：

现在定义一个函数对象如下inserter ，完成的功能是向vector中插入数据，如下可见在实际使用的时候传递两个参数。

struct inserter { 
public: 
    void operator()(double n, vector<double> & v) { v.push_back(n); } 
}; 
inserter f; 
vector<double> vd; 
f(1.0, vd); //两个参数

如果现在有一个算法append是如下定义的，向容器中添加一些数据成员。

template<typename Functor> 
void append(Functor f) { 
    double x; 
    while(cin>>x) 
        f(x); 
}

这时，你的insert就用不上了，因为append的functor只要求一个参数。如果你的inserter本来是一个很复杂的操作，那么如果重写一个就很麻烦。不过有一个简单的办法是再定义一个inserter_adapter。

template<typename Functor> 
struct inserter_adapter { 
    inserter_adapter(const Functor& f, vector<double>& v) 
        :f_(f), v_(v) {} 
    void operator()(double x) { f_(x, v_);} 
    Functor f_; 
    vector<double>& v_; 
}; 
inserter f; 
vector<double> vd; 
inserter_adapter ia(f, vd);  //将vd绑定到操作符f的第二个参数上 
append(ia);

      由以上的场景分析，可以看出inserter_adapter 充当了一个适配器的角色，解决了二元函数对象无法适应一元函数对象操作的情况。因为inserter_adapter 将容器参数对象绑定到了操作符的第二个参数上。

        以上方案实现的是将二元函数对象转化为一元函数对象，这种转化是通过绑定一个操作对象。而在STL中，这种参数绑定操作可以通过以上介绍的binder2nd或者binder1st实现。

struct inserter :public std::binary_function<double, vector<double>&, void> { 
public: 
    void operator()(double n, vector<double> & v) { v.push_back(n); } 
}; 
template<typename Functor> 
void append(Functor f) { 
    double x; 
    while(cin>>x) 
        f(x); 
} 
inserter f; 
vector<double> vd; 
append(std::bind2nd(f, vd)); //bind2nd创建了一个binder2nd对象，将参数vd绑定到操作符f的第二个参数