前言

1. std::bind概述

std::bind是C++11引入的功能模板，位于<functional>头文件中，用于将函数、成员函数或函数对象与特定参数绑定，生成一个新的可调用对象。

1.1 基本用法

#include <iostream>
#include <functional>void print_sum(int a, int b) {std::cout << a + b << std::endl;
}int main() {// 绑定函数和参数auto bound_print = std::bind(print_sum, 10, std::placeholders::_1);bound_print(20);  // 输出30，相当于print_sum(10, 20)return 0;
}

std::bind 将函数 print_sum 和部分参数绑定，生成一个新的可调用对象 bound_print。std::placeholders::_1 表示调用 bound_print 时的第一个参数会传递给 print_sum 的第二个形参 b。绑定时已固定的参数（如 10）在调用时不再需要传入。

默认行为：按值捕获参数

int x = 10;
auto bound = std::bind(f, x);  // x被复制
x = 20;
bound();  // 使用x的副本(值为10)

引用捕获：使用std::ref或std::cref

int x = 10;
auto bound = std::bind(f, std::ref(x));  // x被引用捕获
x = 20;
bound();  // 使用x的引用(值为20)

1.2 占位符

std::placeholders::_1, _2, ..., _N表示调用时传入的第1, 2, ..., N个参数。

void print_values(int a, int b, int c) {std::cout << a << ", " << b << ", " << c << std::endl;
}int main() {auto bound_func = std::bind(print_values, std::placeholders::_2,std::placeholders::_1,100);bound_func(10, 20);  // 输出20, 10, 100return 0;
}

调用 bound_func(10, 20) 时： _1 对应第一个实参 10 → 传给原函数的 b _2 对应第二个实参 20 → 传给原函数的 a c 始终为固定值 100

1.3 绑定成员函数

绑定成员函数时需要传入对象指针或引用：

class MyClass {
public:void print(int x) {std::cout << "Value: " << x << std::endl;}
};int main() {MyClass obj;auto bound_member = std::bind(&MyClass::print, &obj, std::placeholders::_1);bound_member(42);  // 输出Value: 42return 0;
}

成员函数指针`&MyClass::print` 是 `MyClass` 的成员函数 `print` 的指针。在 C++ 中，成员函数指针必须通过类的对象（或指针）来调用。`std::bind` 绑定成员函数`std::bind` 的第一个参数是成员函数指针，第二个参数是对象的指针（`&obj`），后续参数是成员函数的参数（用占位符或固定值）。占位符 `_1``std::placeholders::_1` 表示调用 `bound_member` 时的第一个参数会传递给 `print` 的 `x`。调用方式`bound_member(42)`

2. 完美转发(Perfect Forwarding)

完美转发是指在函数模板中将参数以原始类型转发给另一个函数，保持参数的值类别（左值、右值）不变。

2.1 引用折叠规则

完美转发基于引用折叠规则：

T& & → T& T& && → T& T&& & → T& T&& && → T&&

2.2 完美转发示例

#include <utility>void process(int& x) { std::cout << "lvalue: " << x << std::endl; }
void process(int&& x) { std::cout << "rvalue: " << x << std::endl; }template<typename T>
void wrapper(T&& arg) {process(std::forward<T>(arg));  // 完美转发
}int main() {int x = 10;wrapper(x);       // 调用lvalue版本wrapper(20);      // 调用rvalue版本wrapper(std::move(x)); // 调用rvalue版本return 0;
}

wrapper(x)（左值）x 是左值（有名变量），T 推导为 int&。std::forward<int&>(arg) 返回左值引用。调用 process(int&)，输出 lvalue: 10。

wrapper(20)（右值）20 是右值（临时值），T 推导为 int。std::forward<int>(arg) 返回右值引用。调用 process(int&&)，输出 rvalue: 20。

wrapper(std::move(x))（右值）std::move(x) 将 x 转为右值，T 推导为 int。std::forward<int>(arg) 返回右值引用。调用 process(int&&)，输出 rvalue: 10。