相当于适配器,用于对可调用对象(函数指针,仿函数,lambda)进行封装,使得他们的类型统一。
double func(double d)
{
return d / 4;
}
struct func1
{
double operator()(double d)
{
return d / 4;
}
};
int main()
{
function f1 = [](double d) {return d / 4; };
function f2 = func;
function f3 = func1();
return 0;
}
function
= lambda/函数指针/仿函数匿名对象
包装后的对象可以放在容器中,并调用。
vector> v = { f1,f2,f3 };
for (auto e : v)
{
cout << e(4) << endl;
}
functional 的 bind绑定
从传参的角度对封装好的可调用对象进一步限制
int Sub(int a, int b)
{
return a - b;
}
function rSub = bind(Sub, placeholders::_1,placeholders::_2);
cout << rSub(10, 5) << endl; // 5
function rrSub = bind(Sub, placeholders::_2, placeholders::_1);
cout << rrSub(10, 5) << endl; // -5
rSub的10 对应_1,_1对应a
rrS 的 10 对应_1, _1 对应b
int Add(int a, int b,int rate)
{
return (a - b)*rate;
}
function radd = bind(Add, placeholders::_1, placeholders::_2,10);
cout << radd(10, 5) << endl; //(10-5)*10
Add经过封装后参数只剩下a,b,rate的值被限定成10
function radd = bind(Add, placeholders::_1, 10,placeholders::_2);
cout << radd(10, 5) << endl; // 0
由此可见,bind里面的_1,_2 和函数是以相对位置映射的,而调用时radd的参数顺序和_1数字编号有关和位置顺序无关。
class A
{
public:
static int add(int a, int b)
{
return a + b;
}
int aadd(int a, int b)
{
return a + b;
}
};
function rfunc1 = bind(&A::add, placeholders::_1, placeholders::_2);
// 静态成员函数
A a;
function rfunc2 = bind(&A::aadd,&a, placeholders::_1, placeholders::_2);
function rfunc3 = bind(&A::aadd, A(), placeholders::_1, placeholders::_2);
// 成员函数实际三个参数,this,因此我们可以传对象指针或者匿名对象
bind的第一个参数实际上是函数地址,底层上bind绑定是仿函数。
利用类对象的构造和析构函数来控制指针的生成和释放,即RAII
template
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete pointer"<<_ptr << endl;
}
private:
T* _ptr;
};
void test()
{
SmartPtr ptr(new string());
}
当test函数结束时,会调用析构函数释放指针。
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~SmartPtr()
{
cout << "delete pointer"<<_ptr << endl;
}
private:
T* _ptr;
};