bind绑定器

绑定器 + 二元函数对象 => 一元函数对象

比如要利用greater在find_if()中查找第1个小于70的数

bind1st

bind1st(greater<int>() , 70)

bind2nd

bind1st(less<int>() , 70)

实现

bind

bind是一个函数模板，可以自动推导函数类型

bind（函数 ， 参数）

bind(sum , 10 , 20)();
bind(sum , 10 , _1)(20);
//等效

利用function和bind实现一个线程池

class Thread{
public:
    Thread(function<void()> func) : _func(func){}
    thread start(){
        thread t(_func);
        return t;
    }
private:
    function<void()> _func;
};

class ThreadPool{
public:
    ThreadPool(){}
    ~ThreadPool(){
        //释放Thread的资源
        for(int i = 0 ; i < _pool.size() ; i++){
            delete _pool[i];
        }
    }

    //开启线程池
    void startThreadPool(int size){
        for(int i = 0 ; i < size ; i++){
            _pool.push_back(
                new Thread(bind(&ThreadPool::runInThread , this , i))
            );
        }

        for(int i = 0 ; i <  size ; i++){
            _handler.push_back(_pool[i] -> start());
        }

        for(thread &t : _handler){
            t.join();
        }
    }

private:
    vector<Thread*> _pool;
    vector<thread> _handler;

    //充当线程函数
    void runInThread(int id){
        cout<<"call runInThread : " << id<<endl;
    }
};


signed main(){
    ThreadPool pool;
    pool.startThreadPool(10);
}

function函数对象

函数对象function

function ： 绑定器 ， 函数对象 ， Lambda表达式 他们只能使用在一条语句中

function底层实现

template<typename FUNC>
class Myfunction{};

//对Myfunction进行部分模板实例化
template<typename R , typename... A>
class Myfunction<R(A...)>{
public:
    using PFUNC = R(*)(A...);
    Myfunction(PFUNC f):_FUNC(f){cout<<"FUNC"<<endl;};
    R operator()(A... arg){return _FUNC(arg...);}
private:
    PFUNC _FUNC;
};

C++11 函数对象的升级版 -> lambda表达式

函数对象的缺点：

​ 使用在泛型算法的参数传递 ， 比较性质/自定义操作 ， 优先级队列 ，智能指针的删除器

​ （需要定义一个类，并且需要的

lambda表达式的语法：

[ 捕获外部变量 ] (形参列表) -> 返回值 {操作代码}；