std::bind 与 std::function：参数绑定、占位符、与 Lambda 的对比

好，咱们今天聊点实在的。std::bind 和 std::function 这对组合，在 C++11 之前可是函数式编程的顶梁柱。后来 Lambda 横空出世，很多人就觉得 bind 该退休了。嗯，我个人的看法是——它俩各有各的用武之地，谁也别瞧不起谁。

说白了，std::function 是个万能容器，能装任何可调用对象。而 std::bind 是个适配器，能把函数的参数提前绑死，或者重新排个序。你想想看，这两个东西配合起来，能玩出多少花样？

std::function：可调用对象的通用包装器

先说说 std::function。它是个类型擦除的容器，能存储 lambda、函数指针、成员函数指针、甚至 bind 表达式。我在项目中经常用它来做回调注册，比如事件系统、异步任务队列。

#include <functional>
#include <iostream>

// 普通函数
int add(int a, int b) {
    return a + b;
}

int main() {
    // 存储普通函数
    std::function<int(int, int)> func1 = add;
    std::cout << func1(3, 4) << std::endl; // 7

    // 存储 lambda
    std::function<int(int, int)> func2 = [](int x, int y) {
        return x * y;
    };
    std::cout << func2(3, 4) << std::endl; // 12

    // 存储 bind 表达式
    std::function<int(int)> func3 = std::bind(add, 10, std::placeholders::_1);
    std::cout << func3(5) << std::endl; // 15

    return 0;
}

看到没？同一个 std::function 类型，可以装三种不同的东西。这就是类型擦除的魅力。不过要注意，std::function 有运行时开销，内部会做虚函数调用或者小对象优化。性能敏感的场景，我建议直接用 auto 或者模板。

std::bind：参数绑定与占位符

std::bind 是个神奇的东西。它能把一个多参数函数，变成参数更少的函数。核心就是两个概念：绑定固定值，和占位符。

#include <functional>
#include <iostream>

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

int main() {
    using namespace std::placeholders;

    // 绑定第一个参数为 10，后面两个用占位符
    auto f1 = std::bind(print, 10, _1, _2);
    f1(20, 30); // 输出: 10, 20, 30

    // 重新排列参数顺序
    auto f2 = std::bind(print, _3, _1, _2);
    f2(1, 2, 3); // 输出: 3, 1, 2

    // 全部绑定死
    auto f3 = std::bind(print, 100, 200, 300);
    f3(); // 输出: 100, 200, 300

    return 0;
}

占位符 _1, _2, _3 表示「等我调用时再传进来」。你可以任意排列它们的位置，甚至重复使用。我曾经在写一个策略模式时，用 bind 把不同策略的参数重新映射到统一接口上，省了不少模板代码。

占位符的进阶用法

占位符不只是简单的占位。你可以用它实现参数转发、嵌套绑定、甚至部分求值。来看个稍微复杂点的例子：

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

bool is_greater_than(int threshold, int value) {
    return value > threshold;
}

int main() {
    using namespace std::placeholders;

    std::vector<int> data = {1, 5, 8, 3, 10, 2};

    // 绑定阈值，生成一元谓词
    auto greater_than_5 = std::bind(is_greater_than, 5, _1);
    int count = std::count_if(data.begin(), data.end(), greater_than_5);
    std::cout << "大于5的元素个数: " << count << std::endl; // 3

    // 也可以反过来，把 value 放在第一个参数位置
    auto greater_than_5_v2 = std::bind(is_greater_than, _1, 5);
    // 注意：这样调用时传的是 threshold，语义反了，别搞混

    return 0;
}

这里的关键是：bind 让你把「阈值」这个参数提前固定，生成一个只需要传「值」的新函数。这在 STL 算法里特别有用，因为很多算法只接受一元谓词。

与 Lambda 的对比

好，重头戏来了。Lambda 和 bind 到底怎么选？我个人的经验是：能用 Lambda 就用 Lambda，除非你遇到 bind 特有的优势场景。

举个例子，同样的功能用两种方式实现：

#include <functional>
#include <iostream>

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

int main() {
    using namespace std::placeholders;

    int factor = 2;

    // 用 bind
    auto bind_way = std::bind(multiply, factor, _1, _2);
    bind_way(3, 4); // 输出: 24

    // 用 lambda
    auto lambda_way = [factor](int x, int y) {
        multiply(factor, x, y);
    };
    lambda_way(3, 4); // 输出: 24

    return 0;
}

你觉得哪个更清楚？我反正觉得 lambda 一目了然。bind 的 _1, _2 你得心里默念「第一个参数放这里，第二个放那里」，很累。

实战：用 std::bind 做事件分发

虽然我推荐 Lambda，但 bind 在某些场景确实有不可替代性。比如事件系统里，你需要把不同签名的函数统一成同一种回调：

#include <functional>
#include <iostream>
#include <map>
#include <string>

class EventDispatcher {
public:
    using Callback = std::function<void(const std::string&)>;

    void register_event(const std::string& name, Callback cb) {
        callbacks_[name] = cb;
    }

    void fire(const std::string& name, const std::string& data) {
        auto it = callbacks_.find(name);
        if (it != callbacks_.end()) {
            it->second(data);
        }
    }

private:
    std::map<std::string, Callback> callbacks_;
};

// 不同签名的处理函数
void handle_click(int x, int y, const std::string& extra) {
    std::cout << "点击: (" << x << ", " << y << ") " << extra << std::endl;
}

void handle_keypress(char key) {
    std::cout << "按键: " << key << std::endl;
}

int main() {
    using namespace std::placeholders;

    EventDispatcher dispatcher;

    // 用 bind 把不同签名统一成 void(const string&)
    dispatcher.register_event("click", std::bind(handle_click, 100, 200, _1));
    dispatcher.register_event("keypress", std::bind(handle_keypress, _1));

    dispatcher.fire("click", "左键");
    dispatcher.fire("keypress", "A");

    return 0;
}

这个例子中，handle_click 需要三个参数，handle_keypress 只需要一个。通过 bind，我把它们都包装成了统一的 Callback 类型。如果用 Lambda 也能实现，但 bind 的写法更简洁，尤其是参数很多的时候。

知识体系总览

下面这张图帮你理清 std::bind 和 std::function 在整个函数式编程中的位置：

避坑指南

最后分享几个我踩过的坑，希望能帮你省点时间：

• bind 的引用问题： 默认按值捕获，想传引用必须用 std::ref。我有个同事 debug 了一下午，发现 bind 里的 vector 一直没变，就是因为没加 ref。
• bind 与重载函数： 如果函数有重载，bind 无法自动推导，需要显式指定类型。比如 std::bind((void(*)(int))func, _1)，很丑对吧？所以这种情况我直接上 Lambda。
• std::function 的赋值开销： 频繁赋值 std::function 会触发内存分配。如果性能敏感，考虑用 small function 优化或者直接传模板。
• bind 的嵌套可读性： 我曾经见过三层嵌套的 bind，代码完全没法维护。后来全部改成 Lambda，世界清净了。

嗯，差不多就这些。std::bind 和 std::function 是 C++ 函数式编程的基石，理解它们能帮你更好地理解 Lambda 的设计动机。但实际写代码时，我建议你多想想：这个场景真的需要 bind 吗？还是 Lambda 更清爽？