前言
欢迎订阅 YY滴C++专栏!更多干货持续更新!以下是传送门!
- 我们可以观察下面这段代码,我们会发现我们难以判断
func( )
到底是什么- 因为其有可能是 函数名?函数指针?函数对象(仿函数对象)?也有可能是lamber表达式对象
- 为了方面管理这些【不同的可调用对象的类型问题】 ,我们引入了 function
ret = func(x);
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数指针
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lambda表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
return 0;
}
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明:
Ret: 被调用函数的返回类型
Args…:被调用函数的形参
- function包装器 也叫作 适配器
- C++中的function本质是一个 类模板
- 在以往的学习中,面对不同的可调用对象,我们希望能把他们放到一个vector中方便调用,但是 类型不同显然做不到
- 而function包装器就恰好解决了这个问题(可调用对象的类型问题)
- 如在下面代码中,第一部分
ret = func(x);(可能是函数名?函数指针?函数对象(仿函数对象)?也有可能是lamber表达式对象)
- 我们 通过function语法即可成功把他们放到vector中
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数指针
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lambda表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
// 可调用对象存储到容器中
//vector<>
// 包装器 -- 可调用对象的类型问题
//function<返回值类型(参数类型)>
function<double(double)> f1 = f;// 函数名
function<double(double)> f2 = [](double d)->double { return d / 4; };// 函数对象
function<double(double)> f3 = Functor();// lamber表达式
//vector> v = { f1, f2, f3 };//写法一
//我们 通过function语法即可成功把他们放到vector中
vector<function<double(double)>> v = { f, [](double d)->double { return d / 4; }, Functor() };//写法二
double n = 3.3;
for (auto f : v)
{
cout << f(n++) << endl;//遍历vector,每个元素是一个包装器
}
return 0;
}
- std::bind函数定义在头文件中,是一个 函数模板 ,它就像一个函数包装器(适配器),接受一个可调用对象(callable object),生成一个新的可调用对象来“适应”原对象的参数列表
- 一般主要应用于:实现参数顺序调整等操作
- 如图中所示:
- 同样的
rSub(10,5)
通过变换bind 函数包装器 中placeholders::_1, placeholders::_2
,可以实现10-5&5-10
double Plus(int a, int b, double rate)
{
return (a + b) * rate;
}
int main()
{
function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, placeholders::_2, 4.0);
function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, placeholders::_2, 4.2);
function<double(int, int)> Plus3 = bind(Plus, placeholders::_1, placeholders::_2, 4.4);
cout << Plus1(5, 3) << endl;
cout << Plus2(5, 3) << endl;
cout << Plus3(5, 3) << endl;
return 0;
}
- 如下图所示:
- 即使rate参数放在bind包装器的中间,依然按照placeholders::_1,_2,_3…的顺序走
double Plus(int a, double rate,int b)
{
return (a + b) * rate;
}
int main()
{
function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, 4.0 placeholders::_2);
function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, 4.2,placeholders::_2);
function<double(int, int)> Plus3 = bind(Plus, placeholders::_1,4.4 ,placeholders::_2);
cout << Plus1(5, 3) << endl;
cout << Plus2(5, 3) << endl;
cout << Plus3(5, 3) << endl;
return 0;
}
主要方法分为下面三种:
- 对于静态成员函数,直接取类的地址即可
&SubType::sub
- 对于非静态成员函数,在直接取类的地址的基础上
&SubType::sub
,法一:先实例化出一个类SubType st;
,取其地址&st
- 在直接取类的地址的基础上
&SubType::sub
,法二:直接传入一个匿名对象SubType()
class SubType
{
public:
static int sub(int a, int b)
{
return a - b;
}
int ssub(int a, int b, int rate)
{
return (a - b) * rate;
}
};
int main()
{
//对于静态成员函数
function<double(int, int)> Sub1 = bind(&SubType::sub, placeholders::_1, placeholders::_2);
cout << Sub1(1, 2) << endl;
//对于非静态成员函数,法一
SubType st;
function<double(int, int)> Sub2 = bind(&SubType::ssub, &st, placeholders::_1, placeholders::_2, 3);
cout << Sub2(1, 2) << endl;
//对于非静态成员函数,法二
function<double(int, int)> Sub3 = bind(&SubType::ssub, SubType(), placeholders::_1, placeholders::_2, 3);
cout << Sub3(1, 2) << endl;
return 0;
}