C++ 新特性 | C++ 11 | bind

一、bind

1、概念

std::bind 是 C++11 引入的一个函数适配器，它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表。常用的使用场景如下：

• 使用bind实现参数顺序的调整和将指定参数设置成固定值。
• function 与 bind 结合后，便成为了 C++ 中类成员函数作为回调函数的一种规范的实现方式。

2、std::placeholders 详解

2.1、概念

std::placeholders 是配合 std::bind 使用的占位符，用于表示未绑定的参数位置。它定义在 <functional> 头文件中，包含一组占位符对象 _1, _2, _3,...，分别表示绑定后可调用对象的第一、第二、第三个参数等。

2.2、核心用法

• 基本参数绑定

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

• 参数顺序重排

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

int main() {
    using namespace std::placeholders;
    
    // 原始调用顺序
    print_values(1, 2, 3);  // 输出: a=1, b=2, c=3
    
    // 使用placeholders改变参数顺序
    auto reordered = std::bind(print_values, _3, _1, _2);
    reordered(10, 20, 30);  // 输出: a=30, b=10, c=20
    // 解释:
    // _3 对应调用时的第3个参数(30)→成为print_values的第1个参数(a)
    // _1 对应调用时的第1个参数(10)→成为print_values的第2个参数(b)
    // _2 对应调用时的第2个参数(20)→成为print_values的第3个参数(c)
}

std::placeholders 为 std::bind 提供了强大的参数控制能力，特别适合需要参数重排序或部分参数绑定的场景。

3、使用场景

3.1、部分参数绑定

当一个函数需要多个参数，但在某些情况下，部分参数的值是固定的，此时可以使用 std::bind 预先绑定这些固定的参数，减少后续调用时的参数数量。例如：

#include <iostream>
#include <functional>

// 一个需要三个参数的函数
int add(int a, int b, int c) {
    return a + b + c;
}

int main() {
    // 预先绑定第一个参数为 1
    auto addWithOne = std::bind(add, 1, std::placeholders::_1, std::placeholders::_2);

    // 调用绑定后的函数，只需要提供剩下的两个参数
    int result = addWithOne(2, 3);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

3.2、成员函数绑定

在 C++ 中，调用成员函数需要通过对象或对象指针，使用 std::bind 可以将成员函数和对象绑定在一起，方便调用。例如：

#include <iostream>
#include <functional>

class MyClass {
public:
    void print(int value) {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    // 绑定成员函数和对象
    auto boundPrint = std::bind(&MyClass::print, &obj, std::placeholders::_1);

    // 调用绑定后的函数
    boundPrint(42);

    return 0;
}

3.3、参数重排序

std::bind 可以使用占位符对参数进行重排序，改变原始可调用对象参数的传递顺序。例如：

#include <iostream>
#include <functional>

// 一个需要两个参数的函数
void printNumbers(int a, int b) {
    std::cout << "a: " << a << ", b: " << b << std::endl;
}

int main() {
    // 交换参数顺序
    auto swappedPrint = std::bind(printNumbers, std::placeholders::_2, std::placeholders::_1);

    // 调用绑定后的函数
    swappedPrint(1, 2);

    return 0;
}

4、注意事项

4.1、引用参数的绑定

默认情况下，std::bind 会拷贝参数，如果要绑定引用绑定引用参数需要使用std::ref

错误示例：

void modify(int& x) { x *= 2; }

int value = 10;
auto f = std::bind(modify, value); // 错误：绑定的是value的拷贝
f();
std::cout << value; // 输出10，未被修改

正确示例：

int value = 10;
auto f = std::bind(modify, std::ref(value)); // 正确绑定引用
f();
std::cout << value; // 输出20

4.2、成员函数绑定的对象指针

当绑定成员函数时，必须提供对象指针作为第一个参数。这个指针的生命周期必须至少和绑定后的函数对象一样长。

错误示例：

class Processor {
public:
    void process(int value) { /*...*/ }
};

auto create_callback() {
    Processor p;
    return std::bind(&Processor::process, &p, _1); // 危险！p将很快销毁
} // p离开作用域被销毁

auto cb = create_callback();
cb(42); // 未定义行为，使用已销毁对象

正确示例：

// 使用shared_ptr管理生命周期
auto create_safe_callback() {
    auto p = std::make_shared<Processor>();
    return std::bind(&Processor::process, p, _1);
}

// 或者确保对象生命周期足够长
Processor global_p;
auto safe_cb = std::bind(&Processor::process, &global_p, _1);