C++ std::function 包装器与 bind 绑定详解 | 极客日志

C++

C++ std::function 包装器与 bind 绑定详解

介绍 C++11 引入的 std::function 模板类及其用法。std::function 可封装普通函数、Lambda、仿函数等，实现类型擦除统一接口。通过实际案例展示其在逆波兰表达式求值中的应用。此外，详细讲解了 std::bind 如何修改参数顺序、固定参数值以及绑定类成员函数，增强代码灵活性与复用性。

随缘发布于 2026/3/22更新于 2026/4/16889 浏览

C++ std::function 包装器与 bind 绑定详解

1. 什么是 std::function？

std::function 是 C++11 引入的一个模板类，用于封装任何可调用对象（如普通函数、Lambda 表达式、函数指针、成员函数指针或函数对象等）。它允许你存储一个可调用对象，并在需要时调用它。这使得我们可以更加灵活地编写代码，特别是在需要传递回调函数或异步任务时，std::function 显得尤为重要。

std::function 是通过类型擦除实现的，它可以在运行时动态地将不同类型的可调用对象转化为统一的接口。简单来说，它允许你用一个通用的对象来代替不同类型的函数或函数指针。

2. function 包装器的原型

std::function 在头文件中定义。

// 类模板原型如下
template <class T> function; // undefined
template <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 表达式
 lambda = []( n) { cout <<  << n << endl; };

{
    
    function<()> f;
    f = func;      
    ();
    f = ();    
    ();
    f = lambda;    
    ();
     ;
}

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown转HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。在线工具，Markdown转HTML在线工具，online
HTML转Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML转Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online
JSON美化和格式化
将JSON字符串修饰为友好的可读格式。在线工具，JSON美化和格式化在线工具，online

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();
    }
};

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();
    }
};

template <class Fn, class... Args> bind(Fn&& fn, Args&&... args);

#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;
}

#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;
}

#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;
}

#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;
}