目录
一、function包装器
1、概念
2、function的引入
3、function
1、对函数指针包装
2、对函数对象进行包装
3、对lambda表达式进行包装
4、对类的成员函数进行包装
二、bind包装器
1、概念
2、bind
1、绑定全局函数
2、绑定成员函数
3、参数调换顺序
一、function包装器
1、概念
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
2、function的引入
ret = func(x);上面的func可能是什么呢？那么func可能是函数名，函数指针，函数对象(仿函数对象)，也有可能是lamber表达式对象，所以这些都是可调用的类型。如此丰富的类型，可能会导致模板的效率低下。
接着我们看看下面的场景：
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);
}上面的模板中，即使T的类型保持不变，但是F的类型可能是函数指针，函数对象(仿函数对象)，也有可能是lamber表达式对象。
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;
// lamber表达式
cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;
return 0;
}我们来看看运行结果：
根据上面的运行结果，我们知道了有三个不同的cout变量，上面的useF函数模板被实例化成了三份。
其实这样有些浪费。那么有没有什么方法可以只实例化成一份呢？这就是我们下面要讲解的function包装器。
3、function
std::function在头文件<functional>中。
类模板原型如下，（模板参数说明：Ret: 被调用函数的返回类型，Args…：被调用函数的形参 ）
template <class T> function;
template <class Ret, class... Args>
class function<Ret(Args...)>;使用方法如下：
1、对函数指针包装
int f(int a, int b)
{
return a + b;
}
int main()
{
function<int(int, int)> func1 = f;
cout << func1(1, 2) << endl;
return 0;
}2、对函数对象进行包装
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
int main()
{
function<int(int, int)> func2 = Functor();
cout << func2(1, 2) << endl;
return 0;
}3、对lambda表达式进行包装
int main()
{
function<double(double)> func3 = [](double d)->double{ return d /
4; };
cout << useF(func3, 11.11) << endl;
return 0;
}4、对类的成员函数进行包装
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
function<int(int, int)> func4 = &Plus::plusi;
cout << func4(1, 2) << endl;
function<double(Plus, double, double)> func5 = &Plus::plusd;
cout << func5(Plus(), 1.1, 2.2) << endl;
return 0;
}有了包装器后，我们再来试一试 2 中的代码：
int main()
{
// 函数名
function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
function<double(double)> func3 = [](double d)->double{ return d /
4; };
cout << useF(func3, 11.11) << endl;
return 0;
}使用包装器后的代码运行结果如下：
从上面的运行结果中我们可以看出 cout 是同一个，说明useF的模板只实例化出来了一份。
二、bind包装器
1、概念
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。
2、bind
std::function在头文件<functional>中。
原型如下：
template <class Fn, class... Args>
bind (Fn&& fn, Args&&... args);
// with return type
template <class Ret, class Fn, class... Args>
bind (Fn&& fn, Args&&... args);可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对
象来“适应”原对象的参数列表。
调用bind的一般形式：auto a1 = bind(callable, arg_list);
说明：a1本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用a1时，a1会调用callable，并传给它arg_list中的参数。
注：arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示a1的参数，它们占据了传递给a1的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为a1的第一个参数，_2为第二个参数，以此类推。
注：_1，_2 ...... 定义在 placeholders 命名空间中，代表绑定函数对象的形参。
bind的使用方法如下：
1、绑定全局函数
表示绑定函数 plus，参数分别由调用 func1 的第一，二个参数指定。传参数时只需要传_1与_2的数，不需要再传Plus了。
int Plus(int a, int b)
{
return a + b;
}
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
function<int(int, int)> func1 = bind(Plus, _1, _2);
//auto func1 = std::bind(Plus, _1, _2);
cout << func1(1, 2) << endl;
return 0;
}2、绑定成员函数
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
int main()
{
Sub s;
// 绑定成员函数
function<int(int, int)> func3 = bind(&Sub::sub, s, _1, _2);
return 0;
}3、参数调换顺序
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
int main()
{
Sub s;
function<int(int, int)> func4 = bind(&Sub::sub, s, _2, _1);
cout << func4(1, 2) << endl;
return 0;
}
