10、C++11 核心特性：std::bind与std::placeholders，灵活绑定函数参数。

说实话，C++11 之前，想把一个函数和它的参数“打包”起来，那叫一个费劲。你得自己写仿函数，或者用 boost::bind。我自己刚入行那会儿，为了把一个回调函数塞进一个固定签名的接口里，没少写那些又臭又长的包装类。直到 C++11 带来了 std::bind 和 std::placeholders，这感觉就像是从手动挡换成了自动挡——爽快多了。

今天我们就来聊聊这两个家伙。它们说白了就是“参数适配器”，能让你把一个函数的参数个数、顺序，甚至部分参数的值，在调用之前就固定下来。嗯，这里要注意，它并不是什么黑魔法，而是一种非常实用的编译期多态技巧。

std::bind：把函数和参数“粘”在一起

std::bind 是一个函数模板。它的作用就是接受一个可调用对象（函数、函数指针、成员函数指针、lambda 等），然后绑定一部分参数，生成一个新的可调用对象。我个人习惯把它叫做“函数包装器”。

看个最简单的例子：

#include <iostream>
#include <functional>

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

int main() {
    // 绑定所有参数
    auto f1 = std::bind(printSum, 10, 20);
    f1(); // 输出 30

    // 绑定部分参数，使用占位符
    auto f2 = std::bind(printSum, std::placeholders::_1, 100);
    f2(50); // 输出 150

    return 0;
}

你看，f1 把两个参数都固定死了，调用时不需要传参。f2 只固定了第二个参数，第一个参数留了个“坑”，用 _1 占着。调用 f2(50) 时，50 就填进了那个坑里。

std::placeholders：占位符的艺术

std::placeholders 命名空间里定义了一堆占位符：_1, _2, _3 ... 一直到 _29（具体数量看实现，但够用）。它们的作用就是告诉 std::bind：“这个参数先别绑，等调用的时候再传进来。”

占位符的顺序可以任意调整。你想想看，这能带来什么好处？

• 参数重排： 你可以把原函数的参数顺序打乱。
• 参数忽略： 你可以只绑定你关心的参数，忽略掉不需要的。
• 参数重复： 同一个占位符可以用多次，把同一个参数传给多个位置。

举个例子：

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

int main() {
    // 参数重排：_3 对应第一个参数，_1 对应第三个参数
    auto f = std::bind(printThree, std::placeholders::_3, 
                       std::placeholders::_1, 
                       std::placeholders::_2);
    f(10, 20, 30); // 输出: 30, 10, 20
    return 0;
}

为什么会这样？因为 f(10, 20, 30) 调用时，_1 拿到 10，_2 拿到 20，_3 拿到 30。然后 std::bind 按照你指定的顺序，把 _3（30）传给第一个参数，_1（10）传给第二个，_2（20）传给第三个。说白了，这就是一个“参数映射表”。

绑定成员函数：一个常见的坑

绑定成员函数时，有个细节特别容易翻车。成员函数有一个隐式的 this 指针。所以你需要显式地传入一个对象指针或对象引用。

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

int main() {
    Calculator calc;
    // 绑定成员函数，第一个参数是对象指针
    auto f = std::bind(&Calculator::multiply, &calc, 
                       std::placeholders::_1, 
                       std::placeholders::_2);
    std::cout << f(3, 4) << std::endl; // 输出 12
    return 0;
}

与 std::function 搭配：真正的威力

std::bind 单独用其实有点鸡肋，它真正的威力在于和 std::function 配合。你可以把各种不同签名的函数，通过 std::bind 统一成同一个 std::function 类型。这在回调、事件驱动、策略模式里非常常见。

#include <functional>
#include <iostream>
#include <vector>

void callback1(int x) {
    std::cout << "callback1: " << x << std::endl;
}

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

class Handler {
public:
    void handle(int a, int b, int c) {
        std::cout << "Handler: " << a + b + c << std::endl;
    }
};

int main() {
    std::vector<std::function<void(int)>> callbacks;

    callbacks.push_back(callback1); // 直接匹配
    callbacks.push_back(std::bind(callback2, 10, std::placeholders::_1)); // 适配
    Handler h;
    callbacks.push_back(std::bind(&Handler::handle, &h, 
                                  1, 2, std::placeholders::_1)); // 成员函数适配

    for (auto& cb : callbacks) {
        cb(42); // 统一调用
    }
    return 0;
}

你看，三个完全不同的函数，通过 std::bind 包装后，都变成了 void(int) 的签名。这在设计灵活的系统时，简直不要太方便。

知识体系与核心逻辑

下面这张图，帮你理清 std::bind 和 std::placeholders 在整个 C++ 可调用对象体系中的位置和作用：

实用技巧与避坑指南

在实际项目中，我总结了几条经验，分享给你：

1. 优先考虑 lambda： C++14 之后，lambda 已经非常强大了。对于简单的参数绑定，lambda 的可读性通常比 std::bind 更好。我个人习惯是，只有需要参数重排或者绑定成员函数时，才用 std::bind。
2. 注意引用绑定： std::bind 默认是按值拷贝参数的。如果你需要绑定引用，必须使用 std::ref 或 std::cref。否则你绑定的只是一个副本，修改副本不会影响原变量。
3. 性能开销： std::bind 会引入一些运行时开销（虚函数调用或类型擦除）。在性能敏感的循环中，尽量用 lambda 或直接函数调用。

好了，关于 std::bind 和 std::placeholders 的核心用法就聊到这里。记住，它们不是万能的，但在参数适配这个场景下，确实是一把利器。用好了，代码会灵活很多；用不好，反而会让代码变得晦涩难懂。多在实践中体会吧。

---