[cpp][g.p] 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的第二个参数