目录
1.什么是 std::function？
2. function 包装器的原型
3.使用 function 封装不同类型的函数对象
代码分析
4.实际应用：
5. bind 绑定：修改参数传递顺序和数量
2.1 使用 bind 绑定修改参数传递顺序
2.2. bind 绑定：指定特定参数
2.3. bind 绑定与类成员函数
总结：?
?前言：在现代 C++ 中，std::function 是一个非常有用的工具，它使得函数能够像对象一样传递、存储和调用。随着 C++11 的到来，std::function 被引入到标准库中，成为函数式编程和回调机制的核心组件之一。在这篇博客中，我们将深入探讨 std::function 的工作原理、应用场景及其优缺点。
1.什么是 std::function？
std::function 是 C++11 引入的一个模板类，用于封装任何可调用对象（如普通函数、Lambda 表达式、函数指针、成员函数指针或函数对象等）。它允许你存储一个可调用对象，并在需要时调用它。这使得我们可以更加灵活地编写代码，特别是在需要传递回调函数或异步任务时，std::function 显得尤为重要。
std::function 是通过类型擦除实现的，它可以在运行时动态地将不同类型的可调用对象转化为统一的接口。简单来说，它允许你用一个通用的对象来代替不同类型的函数或函数指针。
2. function 包装器的原型
std::function在头文件<functional>
// 类模板原型如下template <class T> function; // undefinedtemplate <class Ret, class... Args>class function<Ret(Args...)>;模板参数说明：
Ret: 被调用函数的返回类型Args…：被调用函数的形参。
3.使用 function 封装不同类型的函数对象
#include <iostream>#include <functional>#include <string>using namespace std;// 普通函数void func(int n){ cout << "普通函数: " << n << endl;}// 仿函数struct Func{ void operator()(int n) { cout << "仿函数: " << n << endl; }};// Lambda 表达式auto lambda = [](int n) { cout << "Lambda 表达式: " << n << endl; };int main(){ // 使用 std::function 封装不同类型的函数 function<void(int)> f; f = func; // 包装普通函数 f(10); f = Func(); // 包装仿函数 f(20); f = lambda; // 包装 Lambda 表达式 f(30); return 0;}代码分析
我们定义了三个不同类型的函数：一个普通函数 func、一个仿函数 Func 和一个 Lambda 表达式 lambda。
然后，使用 std::function<void(int)> 来封装这三种不同类型的函数对象。
通过调用包装后的 f，我们可以统一的方式执行这些不同的函数对象。(适配器)
这种方式使得我们能够将多种类型的可调用对象统一为一个接口，方便管理和使用。
4.实际应用：
150. 逆波兰表达式求值 - 力扣（LeetCode）
解法一：
class Solution {public: int evalRPN(vector<string>& tokens) { stack<int> st; for(auto& to:tokens) { if(to=="+"||to=="-"||to=="*"||to=="/") { int right=st.top(); st.pop(); int left=st.top(); st.pop(); switch(to[0]) { case '+': st.push(left+right); break; case '-': st.push(left-right); break; case '*': st.push(left*right); break; case '/': st.push(left/right); break; } } else { st.push(stoi(to)); } } return st.top(); }};解法二： 利用function包装器：
class Solution {public: int evalRPN(vector<string>& tokens) { // 解题思路：操作数入栈，遇到操作符，取两个数计算后，入栈 // 建立映射关系 unordered_map<string, function<int(int, int)>> hash = { {"+", [](int x, int y)->int { return x + y; } }, {"-", [](int x, int y)->int { return x - y; } }, {"*", [](int x, int y)->int { return x * y; } }, {"/", [](int x, int y)->int { return x / y; } }, }; stack<int> s; for(auto str : tokens) { if(str != "+" && str != "-" && str != "*" && str != "/") s.push(stoi(str)); else { // 注意：先获取 y，再获取 x int y = s.top(); s.pop(); int x = s.top(); s.pop(); s.push(hash[str](x, y)); } } return s.top(); }};function作为C++11的一个知识，还是非常好用的。?
5. bind 绑定：修改参数传递顺序和数量
bind 是 C++ 标准库中的一个函数模板，它允许我们对函数参数进行预先绑定或重新排列，从而生成一个新的可调用对象。bind 的强大之处在于，它不仅能够指定某些参数的固定值，还能改变参数传递的顺序，极大地提高了灵活性。
函数原型：
template <class Fn, class... Args>bind (Fn&& fn, Args&&... args); fn 是传递的 函数对象，args 是传给函数的 可变参数包，这里使用了 万能引用（引用折叠），使其在进行模板类型推导时，既能引用左值，也能引用右值。
2.1 使用 bind 绑定修改参数传递顺序
#include <iostream>#include <functional>using namespace std;void Func(int a, int b){ cout << "Func: " << a << " " << b << endl;}int main(){ // 正常调用 Func(10, 20); // 使用 bind 改变参数顺序 auto RFunc = bind(Func, std::placeholders::_2, std::placeholders::_1); RFunc(10, 20); // 输出: Func: 20 10 return 0;}代码分析
bind(Func, std::placeholders::_2, std::placeholders::_1) 通过 placeholders::_1 和 placeholders::_2 指定了新的参数顺序，即将原本的第二个参数和第一个参数交换。
当我们调用 RFunc(10, 20) 时，实际上是将 20 作为第一个参数，10 作为第二个参数传递给 Func。
这种参数顺序的改变，在一些特定的应用场景下非常有用，特别是在函数签名不一致时，可以方便地进行适配。
2.2. bind 绑定：指定特定参数
bind 还可以用于指定函数的某些参数为固定值，从而减少后续调用时需要传递的参数个数。
示例代码：使用 bind 绑定指定特定参数
#include <iostream>#include <functional>using namespace std;void Func(int a, int b){ cout << "Func: " << a << " " << b << endl;}int main(){ // 使用 bind 绑定第一个参数 auto RFunc = bind(Func, 100, std::placeholders::_1); RFunc(20); // 输出: Func: 100 20 return 0;}代码分析
我们通过 bind(Func, 100, std::placeholders::_1) 将第一个参数绑定为固定值 100。
后续调用时，我们只需要传递第二个参数 20，bind 会自动将 100 作为第一个参数传递给 Func。
2.3. bind 绑定与类成员函数
bind 还可以用于绑定类成员函数。对于普通函数，绑定非常简单，但对于成员函数，我们需要额外注意如何传递类的对象或指针。
示例代码：使用 bind 绑定静态成员函数
#include <iostream>#include <functional>using namespace std;class Test{public: static void funcA(int val) { cout << "静态成员函数 funcA: " << val << endl; }};int main(){ // 使用 bind 绑定静态成员函数 auto RFunc = bind(&Test::funcA, std::placeholders::_1); RFunc(10); // 输出: 静态成员函数 funcA: 10 return 0;}代码分析
对于静态成员函数，我们可以直接使用 &Test::funcA 来绑定。
bind 会自动处理函数的绑定，并返回一个新的可调用对象 RFunc，我们可以使用它来调用函数。
示例代码：使用 bind 绑定非静态成员函数
#include <iostream>#include <functional>using namespace std;class Test{public: Test(int n) : _n(n) {} void funcB(int val) { cout << "非静态成员函数 funcB: " << val * _n << endl; }private: int _n;};int main(){ Test t(10); // 使用 bind 绑定非静态成员函数 auto RFunc = bind(&Test::funcB, t, std::placeholders::_1); RFunc(5); // 输出: 非静态成员函数 funcB: 50 return 0;}代码分析
对于非静态成员函数，我们需要提供类的对象 t 作为参数来绑定。
bind 会将 t 与 &Test::funcB 结合，并生成一个新的可调用对象。
总结：?
通过 std::function 和 bind，C++ 提供了强大的函数包装和绑定功能，使得我们能够在不同类型的函数之间进行无缝切换、修改参数传递顺序以及绑定特定参数。这些工具极大地增强了代码的灵活性和可重用性，特别是在需要对多个不同函数进行统一管理时，它们提供了非常便捷的解决方案。在实际开发中，这些技巧不仅能帮助我们提升编程效率，还能让代码更加简洁和优雅。