【C++】bind1st bind2nd

泛型函数传入多元函数对象和参数，返回一元函数对象

函数对象 重载()运算符，重组形参与预传入的参数到多元函数

使用

#include <iostream>
#include <string>
#include <functional>
#include <algorithm> // 泛型算法
#include <ctime>
using namespace std;

/*
 * 绑定器和函数对象operator()
 *
 * 1. C++ STL中的绑定器
 * bind1st: operator()的第一个形参变量绑定成一个确定的值
 * bind2nd: operator()的第二个形参变量绑定成一个确定的值
 *
 * 2. C++11 从Boost库中引入了bind绑定器和function函数对象
 *
 * 3. lambda表达式  底层依赖函数对象的机制实现
 */


template<typename Container>
void showContainer(Container& con){
    // 嵌套泛型类型 需要用typename修饰告知编译器Container名称空间下的iterator是类型不是变量
    typename Container::iterator it = con.begin();
    for(; it != con.end(); it++){
        cout << *it << " ";
    }
    cout << endl;
}


int main(){
    vector<int> vec;
    srand(time(nullptr));
    for (int i = 0; i < 20; i++){
        vec.push_back(rand() % 100);
    }
    showContainer(vec);
    // sort(vec.begin(), vec.end()); // 默认小到大排序

    // greator 二元函数对象
    sort(vec.begin(), vec.end(), greater<int>());

    // 把70按顺序插入到vec容器中，找第一个小于70的数字
    // operator()(const T &val)
    // 绑定器 + 二元函数对象 ==> 一元函数对象
    // bind1st: + greater bool operator(70,const _Ty& _Right)
    // bind2nd: + less bool operator(const _Ty& _Left,70)
    // find_if(vec.begin(), vec.end(), greater<int>());
    auto it = find_if(vec.begin(), vec.end(), bind1st(greater<int>(), 70));
    if(it != vec.end()){
        vec.insert(it, 70);
    }
    
    showContainer(vec);

    return 0;
}

实现

#include <iostream>
#include <string>
#include <functional>
#include <algorithm> // 泛型算法
#include <ctime>
// using namespace std;

/*
 * C++11 bind绑定器 ==> 返回的结果还是一个函数对象
 *  1. 函数对象构造时绑定
 *  2. 重载()运算符
 */

using namespace std;

template<typename Iterator, typename Compare>
Iterator my_find_if(Iterator first, Iterator last, Compare comp){
    for (; first != last; ++first){
        if(comp(*first)){  // comp.operator()(*first)
            return first;
        }
    }
    return last;
}

template<typename Compare,typename T>
class _mybind1st{
public:
    _mybind1st(Compare comp,T val)
        :_comp(comp),_val(val)
    {

    }

    //构造一元函数时提前绑定了fist
    bool operator()(const T &second){
            return _comp(_val,second);
    }
private:
    Compare _comp;
    T _val;
};


template<typename Compare,typename T>
class _mybind2nd{
public:
    _mybind2nd(Compare comp,T val)
        :_comp(comp),_val(val)
    {

    }

    //构造一元函数时提前绑定了second
    bool operator()(const T &first){
        return _comp(first,_val); // 二元函数函数 + 函数对象的一元预传参  ++ ()重载
    }
private:
    Compare _comp;
    T _val;
};



template<typename Compare,typename T>
_mybind1st<Compare,T> mybind1st(Compare comp,T &&val){
    return _mybind1st<Compare,T>(comp,val);
}

template<typename Compare,typename T>
_mybind2nd<Compare,T> mybind2nd(Compare comp,T &&val){
    return _mybind1st<Compare,T>(comp,val);
}



template<typename Container>
void showContainer(Container& con){
    // 嵌套泛型类型 需要用typename修饰告知编译器Container名称空间下的iterator是类型不是变量
    typename Container::iterator it = con.begin();
    for(; it != con.end(); it++){
        cout << *it << " ";
    }
    cout << endl;
}

int main(){

    vector<int> vec;
    srand(time(nullptr));
    for (int i = 0; i < 20; i++){
        vec.push_back(rand() % 100);
    }
    showContainer(vec);
    // sort(vec.begin(), vec.end()); // 默认小到大排序

    // greator 二元函数对象
    sort(vec.begin(), vec.end(), greater<int>());

    // 把70按顺序插入到vec容器中，找第一个小于70的数字
    // operator()(const T &val)
    // 绑定器 + 二元函数对象 ==> 一元函数对象
    // bind1st: + greater bool operator(70,const _Ty& _Right)
    // bind2nd: + less bool operator(const _Ty& _Left,70)
    // find_if(vec.begin(), vec.end(), greater<int>());
    auto it = my_find_if(vec.begin(), vec.end(), mybind1st(greater<int>(), 70));
    if(it != vec.end()){
        vec.insert(it, 70);
    }

    showContainer(vec);
    return 0;
}