C++ 中将函数作为参数传递
1. 通过指针传递函数
函数可以通过传递函数的地址来作为参数传递；简而言之，就是通过指针实现这一点。
示例代码
cpp
#include <iostream>
using namespace std;
// 定义加法和减法函数
#include <iostream>
#include <string>
using namespace std;
// 定义拼接字符串的函数
string concatenate(const string& str1, const string& str2) {
return str1 + str2;
}
// 定义转换成大写字母的函数
string to_uppercase(const string& str) {
string result = str;
for (auto& ch : result) {
ch = toupper(ch);
}
return result;
}
// 函数接受指向函数的指针作为参数
string invoke(const string& str1, const string& str2, string (*f)(const string&, const string&)) {
return f(str1, str2);
}
int main() {
string str1 = "Hello, ";
string str2 = "World!";
// 将 concatenate 函数的指针作为参数传递
cout << "Concatenated String: ";
cout << invoke(str1, str2, &concatenate) << '\n'; // 输出拼接的字符串
// 将 to_uppercase 函数的指针作为参数传递
cout << "Uppercase String: ";
cout << invoke(str1, str2, &to_uppercase) << '\n'; // 输出转换成大写的字符串
return 0;
}输出：
Concatenated String: Hello, World!
Uppercase String: HELLO, WORLD!说明：
在这个例子中，concatenate 和 to_uppercase 函数通过指针传递给 invoke 函数。
2. 使用 function<> 包装器
在 C++11 中，std::function 类模板可以将函数作为对象传递，使得将函数作为参数变得更加灵活。
示例代码
cpp
#include <bits/stdc++.h>
using namespace std;
// 定义比较函数
bool greater_than(int x, int y) { return x > y; } // 大于比较
bool less_than(int x, int y) { return x < y; } // 小于比较
// 函数接受 std::function 对象作为参数
bool invoke(int x, int y, function<bool(int, int)> f) {
return f(x, y);
}
int main() {
int a = 20, b = 10;
// 传递比较函数作为 std::function 对象
cout << "Is " << a << " greater than " << b << "? ";
cout << (invoke(a, b, &greater_than) ? "Yes" : "No") << '\n'; // 输出大于比较结果
cout << "Is " << a << " less than " << b << "? ";
cout << (invoke(a, b, &less_than) ? "Yes" : "No") << '\n'; // 输出小于比较结果
return 0;
}输出：
Is 20 greater than 10? Yes
Is 20 less than 10? No说明：
-
在这个例子中，greater_than 和 less_than 函数通过 std::function 被传递给 invoke 函数，以进行数字比较。
-
std::function<bool(int, int)> 是一个可以接收任何具有相同签名（bool(int, int)）的函数对象的容器。
3. 使用 Lambda 表达式
Lambda 表达式是 C++ 提供的一种内联函数的简洁方式，可以在需要函数作为参数的地方直接定义匿名函数。
示例代码
cpp
#include <functional>
#include <iostream>
using namespace std;
// 函数接受 std::function 对象作为参数
int invoke(int x, int y, function<int(int, int)> func) {
return func(x, y);
}
// 主函数
int main() {
// 使用 Lambda 表达式进行加法操作
cout << "Addition: ";
int k = invoke(20, 10, [](int x, int y) -> int { return x + y; });
cout << k << '\n'; // 输出加法结果
// 使用 Lambda 表达式进行减法操作
cout << "Subtraction: ";
int l = invoke(20, 10, [](int x, int y) -> int { return x - y; });
cout << l << '\n'; // 输出减法结果
return 0;
}输出：
Addition: 30
Subtraction: 10说明：
- Lambda 表达式提供了一种非常简洁的方式来定义函数对象。在
invoke函数中，我们直接将一个 Lambda 表达式传递给std::function对象。 - Lambda 的好处是它不需要显式的函数声明，可以直接在调用的地方定义。
4. 传递类的成员函数
如果需要传递类的成员函数作为参数，非静态成员函数的传递会稍微复杂一些，因为成员函数需要绑定到对象上。
示例代码
cpp
#include <bits/stdc++.h>
using namespace std;
class C {
public:
int multiply(int a, int b) {
return a * b; // 成员函数，计算乘积
}
};
void invoke(function<int(int, int)> calc) {
// 调用成员函数
cout << "Product: " << calc(10, 20) << '\n';
}
int main() {
C c; // 创建对象 c
// 使用 bind 绑定成员函数
auto calc = bind(&C::multiply, &c, placeholders::_1, placeholders::_2);
// 传递绑定的成员函数
invoke(calc);
return 0;
}输出：
Product: 200说明：
- 在
main函数中，使用bind将成员函数C::multiply与对象c绑定。 bind返回一个可以作为普通函数调用的对象，我们将其传递给invoke函数。