详解c++中的可调用对象，std::function、Lambda表达式、std::bind等
可调用对象
可调用对象用处广泛，比如在使用一些基于范围的模板函数时（如 sort()、all_of()、find_if() 等），常常需要我们传入一个可调用对象，以指明我们需要对范围中的每个元素进行怎样的处理。 又比如，在处理一些回调函数、触发函数时，也常常会使用可调用对象。
c++中都可调用对象很多包括：Lambda表达式、重载了()运算符的类（仿函数）、普通函数与函数指针、std::bind绑定器、std::function对象等。
void func(int a){
std::cout << "func: " << a << std::endl;
}
void (*func_ptr)(int) = &func;
func_ptr(42); // 通过指针调用
func(444); // 直接调用
上面演示了最简单的可调用对象普通函数与函数指针
std::function
std::function是一个通用的函数封装器，能够存储、复制和调用任何类型的可调用对象。它为多态函数调用提供支持，允许开发者在不知道具体函数类型的情况下，以统一的方式进行函数调用。std::function的用法非常灵活，它可以用于替代函数指针，提供更加丰富的功能。语法如下：
std::function<返回类型(参数类型1, 参数类型2, ...)> func;
下面的例子定义了一个，两个int参数并且返回int的包装器f，它内部存储了我的定义的函数add我们可以像调用add一样调用f
int add(int a, int b) {
return a + b;
}
int main() {
std::function<int(int, int)> f(add);
std::cout << f(2, 3) << std::endl;
return 0;
}
Lambda表达式
Lambda表达式的语法结构：
[捕获列表] (参数列表(可选)) mutable(可选) -> 返回值(可选) { 函数体 }
- 捕获列表：定义了 Lambda 表达式如何访问外部变量，是按值还是按引用的方式访问。捕获列表可以为空，表示不访问任何外部变量，也可以使用默认捕获模式
&或=来表示按引用或按值捕获所有外部变量，这里写入的变量函数体内可以直接使用。我们也可以在捕获列表中初始化变量x = 5，在成员函数中，在类的成员函数中，可以使用 Lambda 表达式捕获this指针，从而访问类的成员变量和成员函数 - 参数列表：这就相当于普通函数的参数列表
- mutable：默认情况下按值捕获的变量在 Lambda 体内是 const 的。使用
mutable可以修改这些副本 - 返回值：我们需要使用
->来指定返回值类型，这里需要注意有返回值就必须有参数列表，参数列表空但是必须有括号
Lambda 表达式的类型是唯一的、未命名的闭包类型。通常我们使用auto来声明 Lambda 变量。如果需要存储 Lambda 或传递它，可以使用std::function
int main() {
std::string s{"fdsa"};
int a = 10;
auto func = [str = std::move(s), &a](auto b) mutable -> std::string {
std::cout << str << std::endl;
str = "abcde";
a = 20;
return std::to_string(b);
};
std::cout << func(10) << " " << a << std::endl;
return 0;
}
上面完整演示了一个Lambda表达式的使用，我们在捕获列表里面，通过移动构造初始化了一个字符串类型，并且引用捕获了int类型a，在使用引用捕获时需要注意生命周期的问题，避免悬空引用的出现。参数使用了auto类型推导参数，添加了mutable关键字可以修改捕获列表中的变量，返回值是普通的字符串类型
下面演示使用std::function存储Lambda 表达式，并且进行函数间的传递的演示，我们设计了一个简单的回调函数示例
void processNumber(int num, std::function<std::string(int)> callback) {
std::string result = callback(num);
std::cout << "处理结果: " << result << std::endl;
}
int main() {
int multiplier = 5;
std::function<std::string(int)> callback = [multiplier](int x) -> std::string {
return std::to_string(x * multiplier);
};
processNumber(10, callback);
processNumber(7, [](int x) {
return std::to_string(x + 100);
});
return 0;
}
std::bind绑定器
std::bind可以将可调用对象和其参数一起绑定，从而生成一个新的可调用对象，语法结构如下：
auto newCallable = std::bind(func, args...);
我们可以在绑定的使用提前传入一些参数，也可以使用定义在 std::placeholders 命名空间中占位符暂时空出参数，分别为 _1、_2、_3 等，它们依次代表调用新可调用对象时传入的第一个、第二个、第三个参数，以此类推。
int add(int a, int b, std::string c, int d) {
std::cout << c << std::endl;
return a + b + d;
}
int main() {
auto f = std::bind(add, 1, std::placeholders::_1, "fsdfa", std::placeholders::_2);
std::cout << f(2, 3) << std::endl;
return 0;
}
这段代码定义了一个名为 add 的函数，该函数接收两个整数、一个字符串和一个整数作为参数，打印出字符串并返回前两个整数与最后一个整数的和。在 main 函数中，使用 std::bind 将 add 函数与部分参数进行绑定，生成一个新的可调用对象 f，然后调用 f 并输出结果。我们将参数a和d提前传入了值，而b和c使用了占位符后期传递
在 C++ 里，成员函数的调用依赖于对象实例。所以，在使用 std::bind 绑定成员函数时，需要提供一个对象指针或者引用。
class Calculator {
public:
int add(int a, int b) {
return a + b;
}
};
int main() {
Calculator calc;
auto boundAdd = std::bind(&Calculator::add, &calc, std::placeholders::_1, std::placeholders::_2);
std::cout << boundAdd(3, 4) << std::endl;
return 0;
}
在这个例子中，&Calculator::add 是成员函数指针，&calc 是对象指针。std::bind 把成员函数和对象绑定在一起，生成一个新的可调用对象 boundAdd。
std::bind 还能够绑定成员变量。绑定成员变量时，会返回一个可调用对象，调用这个对象就能获取或者修改成员变量的值。
class Data {
public:
int value = 42;
};
int main() {
Data data;
auto getValue = std::bind(&Data::value, &data);
getValue() = 4;
std::cout << getValue() << std::endl;
return 0;
}
在这个例子中，&Data::value 是成员变量指针，&data 是对象指针。std::bind 生成一个新的可调用对象 getValue，调用它就能获取 data 对象的 value 成员变量的值。
std::bind也可以通过std::function存储封装的对象
仿函数
在 C++ 中，仿函数（Functor）也被称为函数对象（Function Object），它是一种行为类似函数的对象。仿函数本质上是一个类或结构体，通过重载 () 运算符，使得该类的对象可以像函数一样被调用。与普通函数不同，仿函数可以包含状态。这意味着仿函数对象可以在多次调用之间保存信息。
class Counter {
private:
int count = 0;
public:
int operator()() {
return ++count;
}
};
int main() {
Counter counter;
std::cout << counter() << std::endl;
std::cout << counter() << std::endl;
return 0;
}
在这个例子中，Counter 仿函数内部有一个 count 成员变量，每次调用 counter() 时，count 的值会递增。