C++ 11中的std::bind和std::function
C++11中的std::bind和std::function
目录
可调用对象
- 是一个函数指针
- 一个类成员函数指针
- 可被转换成函数指针的类对象
- 是一个具有operator()成员函数的类的对象
std::bind
std::bind可以理解为“绑定”
绑定普通函数，绑定静态普通函数
int AddFunc(int a, int b) { return a + b; }
auto FuncBind = std::bind(AddFunc, 2, 3); //AddFunc隐式转换为一个函数指针
std::cout << FuncBind() << std::endl; // 5
函数AddFunc被绑定到了FuncBind，而它的参数绑定到一个具体的值上，这个例子中绑定到了2和3，因此在函数调用的时候程序给出的结果是5
参数还可以绑定到占位符（std::placeholders）上，在调用FuncBind时再给出其参数值
auto FuncBind = std::bind(AddFunc, std::placeholders::_1, 3);
std::cout << FuncBind(5) << std::endl; // 8
占位符，顾名思义，它替“5”占了一个 位子，后续调用时，“5”来了，坐了别人给他占的座位。你当然也可以给“3”提供一个占位符
std::bind(AddFunc, std::placeholders::_1, std::placeholders::_2);
FuncBind(6,9); //15
C++提供了多达20个占位符（_1, _20）可供使用。什么？嫌太少？你见过有函数一次性调用二三十个参数的吗？
静态普通函数与普通函数同理，不再赘述
绑定成员函数
- 第一个参数为对象的成员函数指针，且由于其不支持类成员函数隐式转换为函数指针，所以需要手动加上取值符&
- 使用对象成员函数的指针时，需要指定该指针属于那个对象。所以需要创建出一个对象实例并将它的地址当作参数
class MyClass {
public:
int Sum(int a, int b) { return a + b; }
};
MyClass myc;
auto FuncBind = std::bind(&MyClass::Sum, &myc, 10, 20);
//调用FuncBind的结果为：30
绑定静态成员函数
与成员函数不同，你不再需要提供一个对象的指针了
class MyClass {
public:
static int Sum(int a, int b) { return a + b; }
};
MyClass myc;
auto FuncBind = std::bind(&MyClass::Sum, 10, 20);
//调用FuncBind的结果为：30
绑定模板函数
绑定引用参数
std::ref用于包装按引用传递的值
std::cref用于包装按常量引用传递的值
int Sum(int& a, const int& b) { return a++ + b; }
int a = 1, b = 2;
auto FuncBind = std::bind(Sum, std::ref(a), std::cref(b)); //运行后，a = 2， b = 2， 结果为3
总结
std::bind预先绑定的参数需要传递具体变量或者值进去，同时此过程是pass-by-value，如果想以pass-by-reference的形式进行传递，则需要使用std::ref或是std::cref- 若不想预先传值，则需要传入占位符，从
std::placeholders_1开始，逐步递增，此过程为pass-by-reference
std::function
封装函数
std::function是一种通用，多态的函数封装。可容纳各种可调用对象，例如普通函数，函数指针，Lambda表达式以及std::bind表达式等。换句话说，可以当作是函数的容器。对于类型不安全的函数指针来说，将其封装成一个安全的std::function对象是一个良好的选择
假设有一个简单的普通函数
int AddFunc(int a, int, b) { return a + b; }
利用std::function进行封装
int (*MyFuncP)(int, int) = AddFunc; //使用函数指针
std::function<int(int, int)> MyFunc = AddFunc; //利用std::function进行封装
与std::bind配合使用
像是封装函数对象（其实就是operator()），Lambda表达式等其他可调用对象的过程与上述类似，不再赘述，重点关注std::function和std::bind搭配使用
class MyClass {
public:
int Sum(int a, int b) { return a + b; }
int num;
};
using namespace std::placeholders;
MyClass myc;
std::function<int(int, int)> MyFunc = std::bind(&MyClass::Sum, &myc, _1, _2); //绑定成员函数
std::function<int&()> MyValue = std::bind(&MyClass::num, &myc); //绑定成员变量
MyValue() = 100; //等效于 myc.num = 100;
与函数指针对比
使用std::function+std::bind
class Base
{
public:
void Called() {
for (int i = 0; i < myVec.size(); i++)
myVec[i]();
}
protected:
std::vector<std::function<void()>> myVec;
};
class Devired : public Base
{
public:
Devired()
{
std::function<void()> st = std::bind(&Devired::DoSomething, this);
std::function<void()> et = std::bind(&Devired::DoEverything, this);
myVec.emplace_back(st);
myVec.emplace_back(et);
}
private:
void DoSomething() { std::cout << "Some\n"; }
void DoEverything() { std::cout << "Every\n"; }
};
在主函数中通过基类中的函数以及成员调用到派生类的方法
Devired dr;
dr.Called(); //控制台输出 Some Every
使用函数指针
class BaseP
{
public:
void Called() {
for (int i = 0; i < myVec.size(); i++)
myVec[i]();
}
protected:
std::vector<void(*)()> myVec;
};
在基类中将创建一个装 void返回值的无参函数指针 的容器，然后在派生类的构造函数中将派生类成员函数加进容器中
//省略其余部分
DeviredP()
{
auto st = &DeviredP::DoSomething;
auto et = &DeviredP::DoEverything;
myVec.emplace_back(st);
myVec.emplace_back(et);
}
这种写法是错误的，调用drp.Called()时会报错
派生类
class BaseP { virtual void Called() = 0; };
class DeviredP : public BaseP
{
public:
DeviredP()
{
auto st = &DeviredP::DoSomething;
auto et = &DeviredP::DoEverything;
myVec.emplace_back(st);
myVec.emplace_back(et);
}
void Called() override
{
for (int i = 0; i < myVec.size(); i++)
(this->*myVec[i])(); //需要用this指针指明
}
private:
std::vector<void(DeviredP::*)()> myVec; //需指定类名：储存的是DeviredP类的成员函数指针
void DoSomething() { std::cout << "Some\n"; }
void DoEverything() { std::cout << "Every\n"; }
};
不仅储存指针的时候变繁琐了，调用时还应使用this显示指明。而且还需要在每个不同的派生类间去书写相同的代码，项目变得冗长。
使用函数指针的版本无法在基类中取到派生类的函数指针，调用逻辑也需要在子类中去实现。而使用std::function，函数都被统一归为function函数对象，方便基类调用
漫漫谈
虚函数与std::function
虚函数的方法实现责任链模式
struct Request { int RequestType; };
class Handler
{
public:
void setNext(std::shared_ptr<Handler> shrd) { nextHandler = std::move(shrd); }
virtual void HandlerRequest(Request rq)
{
if (nextHandler)
nextHandler->HandlerRequest(rq);
else
std::cout << "Cant Handle\n";
}
protected:
std::shared_ptr<Handler> nextHandler;
};
class DeviredHandler1 : public Handler
{
public:
void HandlerRequest(Request rq) override
{
if (rq.RequestType == 1)
std::cout << "Handle by 1\n";
else
Handler::HandlerRequest(rq);
}
};
// DeviredHandler2，DeviredHandler3...
Request r = { 3 };
auto d1 = std::make_shared<DeviredHandler1>();
auto d2 = std::make_shared<DeviredHandler2>();
auto d3 = std::make_shared<DeviredHandler3>();
d1->setNext(d2);
d2->setNext(d3);
d1->HandlerRequest(r); // Handle by 3
std::bind + std::function方式实现责任链模式
在原有的基础上增加ChainHandler类
using MyFunc = std::function<void(Request)>;
class ChainHandler
{
public:
MyFunc Myfunc;
void HandleRequest(Request rq) { Myfunc(rq); }
void Assemble(MyFunc call, MyFunc next, Request rq)
{
if (next != nullptr)
next(rq);
else
call(rq);
}
};
//main函数中不再使用 d1->HandlerRequest(r);
ChainHandler chain;
MyFunc m1 = std::bind(&DeviredHandler1::HandlerRequest, d1, std::placeholders::_1);
MyFunc m2 = std::bind(&DeviredHandler2::HandlerRequest, d2, std::placeholders::_1);
MyFunc m3 = std::bind(&DeviredHandler3::HandlerRequest, d3, std::placeholders::_1);
chain.Myfunc = std::bind(&ChainHandler::Assemble, &chain, m1, chain.Myfunc, std::placeholders::_1);
chain.Myfunc = std::bind(&ChainHandler::Assemble, &chain, m2, chain.Myfunc, std::placeholders::_1);
chain.Myfunc = std::bind(&ChainHandler::Assemble, &chain, m3, chain.Myfunc, std::placeholders::_1);
chain.HandleRequest(r); // Handle by 3
使用std::function创建一个自动注册工厂
摸了，下次一定
