c++ std::bind函数绑定

bind需引用头文件

# include<functional>

bind使用场景：

1. 将函数转为另一个函数的入参（比如回调函数）
2. 减少函数参数
3. 延迟调用

用法：
std::placeholders用于占位，即当真正调用时才会传入参数

1.绑定普通函数

#include <iostream>
#include <functional>

std::tuple<int, std::string> dorequest(const std::string& data)
{
    int rtncode = 0;
    std::string errinfo;

    if (data == "") {
        return std::make_tuple(-1, "reqdata is null");
    }

    //业务处理

    return std::make_tuple(rtncode, errinfo);
}

int main(int argc, char* argv[])
{
    auto func = std::bind(dorequest, std::placeholders::_1);    //std::placeholders用于占位，即当真正调用时才会传入参数
    func("req");
    return 0;
}

2.绑定成员函数
绑定时需传入当前类对象指针

    MyClass obj;  
    auto func= std::bind(&MyClass::func, &obj);

3.减少函数参数

这个用法的使用场景就是减少关联关系，减少头文件的include
比如：我bind了一个函数（入参为class Session，string data），这个函数对象会在另一个doreq.cpp文件里被调用，如果不减少参数，那在doreq.coo文件中需要include 类Session的头文件，不然在声明回调函数的类型std::function时会报错

#include <iostream>
#include <functional>

Class Session
{
public:
    Session(){}
    ~Session(){}

    send(const std::string& data){}
};

int dorequest(std::shared_ptr<Session> ssesion, const std::string& data)
{
    int rtncode = 0;
    std::string errinfo;
    std::string reponse;

    if (data == "") {
        return -1;
    }

    //业务处理

    //处理完
    session->send(reponse);
    return rtncode;
}

int main(int argc, char* argv[])
{
    auto session =std::make_shared<Session>();
    std::function<int(string)>func = std::bind(dorequest, session, std::placeholders::_1);    //std::placeholders用于占位，即当真正调用时才会传入参数
    //调用时不需要传session了 只需要传data. 
    //如果在其他文件里调用，则只需要声明func类型为std::function<int (string)>
    //且不用include 类Session的头文件
    func("req");
    return 0;
}