19. std::bind 与占位符：参数绑定，与 Lambda 的对比

好，咱们今天聊一个老伙计——std::bind。说实话，我在C++11刚出来那会儿，对bind是又爱又恨。爱的是它确实能解决一些棘手的问题，恨的是它的语法……嗯，有点反直觉。后来Lambda普及了，bind用得少了，但有些场景它依然有不可替代的价值。

19.1 std::bind 是什么？

简单说，std::bind是一个函数适配器。它可以把一个函数的某些参数“固定”下来，生成一个新的可调用对象。你想想看，有时候你有一个接受三个参数的函数，但实际调用时，前两个参数每次都一样，只有第三个在变。这时候bind就派上用场了。

#include <functional>
#include <iostream>

void printSum(int a, int b, int c) {
    std::cout << a + b + c << std::endl;
}

int main() {
    // 绑定前两个参数为10和20，第三个参数留空
    auto boundFunc = std::bind(printSum, 10, 20, std::placeholders::_1);
    boundFunc(30);  // 输出 60
    return 0;
}

这里std::placeholders::_1就是占位符。它告诉bind：“第三个参数先别定，等调用的时候再给我。” 我个人习惯把占位符理解为“预留的插槽”，你留几个插槽，调用时就要传几个参数。

19.2 占位符的玩法

占位符不止一个。_1、_2、_3……一直到_29（标准库实现通常支持这么多）。它们可以重新排列参数顺序，这个特性很有意思。

void show(int x, int y, int z) {
    std::cout << x << " " << y << " " << z << std::endl;
}

int main() {
    // 把参数顺序颠倒过来
    auto reversed = std::bind(show, std::placeholders::_3,
                              std::placeholders::_2,
                              std::placeholders::_1);
    reversed(1, 2, 3);  // 输出 3 2 1
    return 0;
}

我在项目中遇到过这样一个场景：有个第三方库的回调函数要求参数顺序是(int, double, string)，但我手里的数据正好是反的。用bind重排一下参数顺序，几行代码就搞定了，不用再写一层包装函数。

19.3 绑定成员函数

绑定成员函数是bind的另一个经典用法。注意，成员函数有个隐式的this指针，你得显式传进去。

class Calculator {
public:
    int multiply(int a, int b) const {
        return a * b;
    }
};

int main() {
    Calculator calc;
    // 绑定成员函数和对象
    auto boundMul = std::bind(&Calculator::multiply, &calc,
                              std::placeholders::_1,
                              std::placeholders::_2);
    std::cout << boundMul(3, 4) << std::endl;  // 输出 12
    return 0;
}

这里有个坑，我曾经踩过：如果你传的是对象副本而不是指针，bind会拷贝整个对象。对于大对象，性能损耗不小。建议传指针或者std::ref包装的引用。

19.4 std::bind 与 Lambda 的对比

好，重头戏来了。bind和Lambda到底选哪个？我个人的经验是：能用Lambda就别用bind。但这不是绝对的，咱们看个对比表。

特性	std::bind	Lambda
语法简洁性	啰嗦，占位符容易混淆	直观，一目了然
参数重排	天然支持，占位符随意排列	需要手动写参数列表
捕获方式	值捕获、引用捕获（需std::ref）	值捕获、引用捕获、移动捕获（C++14）
内联优化	编译器较难内联	编译器容易内联，性能更好
调试体验	错误信息晦涩难懂	错误信息相对清晰
泛型编程	配合模板较麻烦	支持auto参数（C++14）

说白了，Lambda是C++11之后更现代、更推荐的方式。但bind在某些场景下依然有优势，比如参数重排。你想想看，用Lambda重排参数你得写：

auto reversed = [](int a, int b, int c) {
    show(c, b, a);
};

而bind一行搞定。不过话说回来，这种场景在实际项目中并不多见。

19.5 什么时候该用 std::bind？

我总结了三个场景，bind依然值得考虑：

1. 与旧代码集成：有些老项目大量使用std::bind1st、std::bind2nd，迁移到std::bind是平滑过渡。
2. 需要参数重排：就像前面说的，占位符可以灵活调整参数顺序。
3. 配合标准库算法：某些算法需要特定签名的可调用对象，bind可以快速适配。

19.6 避坑指南

我曾经在代码审查里看到过这样的写法：

auto badBind = std::bind(&SomeClass::method, this);  // 危险！
// 如果this指向的对象被销毁，badBind就悬空了

嗯，这里要注意。bind不会延长对象的生命周期。如果你需要异步调用成员函数，建议用Lambda配合shared_from_this()：

auto safeLambda = [self = shared_from_this()]() {
    self->method();
};

另外，bind的嵌套使用会让代码变得极其难读。我见过有人写std::bind(std::bind(...), ...)，调试的时候简直想骂人。这种时候，拆成几个Lambda或者用auto推导中间结果，可读性会好很多。

19.7 知识体系图

下面这张图梳理了本章的核心逻辑，从bind的基本用法到与Lambda的对比，再到实际选型建议。

19.8 总结

std::bind是C++11引入的一个强大工具，但它不是万能的。我个人建议：新代码优先用Lambda，维护旧代码时理解bind的语义。占位符的灵活性的确是Lambda难以替代的，但为了代码的可读性和可维护性，这点灵活性不值得滥用。

最后送大家一句话：代码是写给人看的，顺便给机器执行。bind的写法虽然酷，但你的同事可能会恨你。嗯，就这样。