高阶函数
在 C++中，高阶函数是指可以接受函数作为参数或者返回函数的函数。
一、使用函数指针实现高阶函数
接受函数指针作为参数：
以下是一个使用函数指针作为参数的高阶函数示例，用于对一个整数数组进行操作：
#include <iostream>
void processArray(int arr[], int size, void (*func)(int)) {
for (int i = 0; i < size; i++) {
func(arr[i]);
}
}
void printValue(int value) {
std::cout << value << " ";
}
void doubleValue(int value) {
std::cout << value * 2 << " ";
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof(arr) / sizeof(arr[0]);
std::cout << "Original array: ";
processArray(arr, size, printValue);
std::cout << std::endl;
std::cout << "Doubled array: ";
processArray(arr, size, doubleValue);
std::cout << std::endl;
return 0;
}在这个例子中，processArray函数是一个高阶函数，它接受一个整数数组、数组大小和一个函数指针作为参数。这个函数指针指向一个接受一个整数参数并返回 void 的函数。在main函数中，分别传入printValue和doubleValue函数作为参数，对数组进行不同的操作。
返回函数指针：
以下是一个返回函数指针的高阶函数示例：
#include <iostream>
int (*selectOperation(char op))(int, int) {
if (op == '+') {
return [](int a, int b) { return a + b; };
} else if (op == '-') {
return [](int a, int b) { return a - b; };
} else {
return nullptr;
}
}
int main() {
int (*addFunc)(int, int) = selectOperation('+');
int (*subFunc)(int, int) = selectOperation('-');
std::cout << "Addition: " << addFunc(5, 3) << std::endl;
std::cout << "Subtraction: " << subFunc(5, 3) << std::endl;
return 0;
}在这个例子中，selectOperation函数是一个高阶函数，它根据传入的操作符返回一个指向相应函数的函数指针。这个函数指针指向一个接受两个整数参数并返回一个整数的函数。
二、使用函数对象（仿函数）实现高阶函数
接受函数对象作为参数：
以下是一个使用函数对象作为参数的高阶函数示例：
#include <iostream>
#include <algorithm>
class MultiplyBy {
public:
MultiplyBy(int factor) : factor(factor) {}
int operator()(int value) const {
return value * factor;
}
private:
int factor;
};
void processArray(int arr[], int size, MultiplyBy multiplyBy) {
std::transform(arr, arr + size, arr, multiplyBy);
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof(arr) / sizeof(arr[0]);
MultiplyBy multiplyBy3(3);
processArray(arr, size, multiplyBy3);
for (int i = 0; i < size; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}在这个例子中，processArray函数接受一个整数数组、数组大小和一个函数对象作为参数。函数对象MultiplyBy实现了一个可调用的运算符operator()，用于对整数进行乘法操作。
返回函数对象：
以下是一个返回函数对象的高阶函数示例：
#include <iostream>
#include <functional>
std::function<int(int)> createAdder(int valueToAdd) {
return [valueToAdd](int value) {
return value + valueToAdd;
};
}
int main() {
std::function<int(int)> add5 = createAdder(5);
std::function<int(int)> add10 = createAdder(10);
std::cout << "Add 5 to 3: " << add5(3) << std::endl;
std::cout << "Add 10 to 7: " << add10(7) << std::endl;
return 0;
}在这个例子中，createAdder函数是一个高阶函数，它接受一个整数作为参数，并返回一个std::function对象，这个对象表示一个接受一个整数参数并返回一个整数的函数。返回的函数对象将传入的参数与固定的值相加。
三、使用 lambda 表达式实现高阶函数
接受 lambda 表达式作为参数：
以下是一个使用 lambda 表达式作为参数的高阶函数示例：
#include <iostream>
#include <algorithm>
void processArray(int arr[], int size, const std::function<int(int)>& func) {
std::transform(arr, arr + size, arr, func);
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof(arr) / sizeof(arr[0]);
processArray(arr, size, [](int value) { return value * 2; });
for (int i = 0; i < size; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}在这个例子中，processArray函数接受一个整数数组、数组大小和一个std::function对象作为参数。这个std::function对象可以接受一个整数参数并返回一个整数，可以用 lambda 表达式来初始化。
返回 lambda 表达式：
以下是一个返回 lambda 表达式的高阶函数示例：
#include <iostream>
#include <functional>
std::function<int(int)> createOperation(char op) {
if (op == '+') {
return [](int value) { return value + 5; };
} else if (op == '-') {
return [](int value) { return value - 3; };
} else {
return [](int value) { return value; };
}
}
int main() {
std::function<int(int)> addFunc = createOperation('+');
std::function<int(int)> subFunc = createOperation('-');
std::cout << "Add 5 to 3: " << addFunc(3) << std::endl;
std::cout << "Subtract 3 from 7: " << subFunc(7) << std::endl;
return 0;
}在这个例子中，createOperation函数是一个高阶函数，它根据传入的操作符返回一个 lambda 表达式，这个 lambda 表达式接受一个整数参数并返回一个整数。
高阶函数在 C++中可以提高代码的灵活性和可重用性，使代码更加简洁和易于维护。通过使用函数指针、函数对象或 lambda 表达式，可以实现不同类型的高阶函数，满足各种编程需求。
Last updated