简介
仿函数（functor）主要是在C++中使用的一个概念。仿函数是一个行为类似函数的对象，它们通过重载函数调用运算符operator()来实现。仿函数可以携带状态，这一点与普通函数有所不同。
简言之，仿函数是重载了 operator() 的类或者结构体。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
仿函数的特性
- 状态存储：仿函数可以持有状态，允许在多次调用之间保持信息，提供比普通函数更强的功能。
假设我们有一个需要计算加权和的函数，不同实例会使用不同的权重。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
cpp
#include <iostream>
// 一个简单的仿函数类，用于加权和计算
class WeightedSum {
private:
int weight;
public:
// 构造函数，初始化权重
WeightedSum(int w) : weight(w) {}
// 重载函数调用运算符，执行加权和计算
int operator()(int value) const {
return value * weight;
}
};
int main() {
WeightedSum wsum1(2); // 创建一个权重为2的仿函数对象
WeightedSum wsum2(3); // 创建一个权重为3的仿函数对象
std::cout << "5 weighted by 2 is " << wsum1(5) << std::endl; // 输出10
std::cout << "5 weighted by 3 is " << wsum2(5) << std::endl; // 输出15
return 0;
}
在上面的例子中，wsum1和wsum2两个实例持有不同的权重状态，并在操作中使用这个权重。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
- 灵活性：仿函数可以有多个实例，每个实例可以有不同的状态，使得一个接口可以表现出多种行为。
仿函数不仅可以保存状态，而且每个实例可以有不同的状态，显著提高了灵活性。这种能力使得我们可以创建多个行为不同的函数对象，而这些对象共享相同的接口（重载的operator()）。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
示例： 以下示例展示了不同的阈值过滤器，尽管它们实现同样的接口，但行为不同。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
cpp
#include <iostream>
#include <vector>
// 仿函数类，用于实现不同的阈值过滤器
class ThresholdFilter {
private:
int threshold;
public:
// 构造函数，初始化阈值
ThresholdFilter(int t) : threshold(t) {}
// 重载函数调用运算符，执行阈值过滤
bool operator()(int value) const {
return value > threshold;
}
};
int main() {
std::vector<int> numbers = {1, 4, 6, 8, 3, 5};
// 创建不同的阈值过滤器对象
ThresholdFilter filterLow(3);
ThresholdFilter filterHigh(6);
// 使用低阈值过滤器
std::cout << "Numbers greater than 3: ";
for (int n : numbers) {
if (filterLow(n)) {
std::cout << n << " ";
}
}
std::cout << std::endl;
// 使用高阈值过滤器
std::cout << "Numbers greater than 6: ";
for (int n : numbers) {
if (filterHigh(n)) {
std::cout << n << " ";
}
}
std::cout << std::endl;
return 0;
}
- 重用性：仿函数将逻辑封装在类中，易于复用，增强代码的清晰度和可维护性。
仿函数将逻辑封装在类中，通过重载operator()，可以将相同的逻辑复用在不同的上下文中。代码重用提高了代码的可维护性和可读性。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
示例： 假设我们想要计算不同的人群的年龄加权值，这里可以用相同的逻辑，区别在于每个对象的状态不同。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
cpp
#include <iostream>
#include <vector>
#include <numeric>
// 仿函数类，用于年龄加权计算
class AgeWeight {
private:
int weight;
public:
// 构造函数，初始化权重
AgeWeight(int w) : weight(w) {}
// 重载函数调用运算符，执行加权计算
int operator()(int sum, int age) const {
return sum + age * weight;
}
};
int main() {
std::vector<int> ages = {20, 30, 40};
AgeWeight childrenWeight(2); // 定义儿童加权对象
AgeWeight adultsWeight(1); // 定义成人加权对象
// 从 `ages` 容器的开始到结束进行累加，初值为 0，每次调用 `childrenWeight` 仿函数进行加权计算。
int totalChildrenWeight = std::accumulate(ages.begin(), ages.end(), 0, childrenWeight);
int totalAdultsWeight = std::accumulate(ages.begin(), ages.end(), 0, adultsWeight);
// 1. 初始值为0：sum = 0。
// 2. 第一次加权计算：
// - `sum = 0 + 20 * 2 = 40`
// 3. 第二次加权计算：
// - `sum = 40 + 30 * 2 = 100`
// 4. 第三次加权计算：
// - `sum = 100 + 40 * 2 = 180` 所以 `totalChildrenWeight` 为 180。
std::cout << "Total weighted age for children: " << totalChildrenWeight << std::endl;
std::cout << "Total weighted age for adults: " << totalAdultsWeight << std::endl;
return 0;
}
回调
仿函数常被用于实现回调上，在C++中，回调是一种能够让一个函数在某些事件发生时被调用的机制。你可以把回调函数看作是函数指针，这些指针被传递给其他函数用于在特定条件下进行调用。回调可以用来实现异步操作、事件处理、以及各种库和框架中的扩展点。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
基本概念
- 函数指针：这是最简单的一种回调方法，通过传递函数指针来实现。
- 仿函数（函数对象） ：使用重载
operator()的对象。 - std::function 和 std::bind：C++11引入了
std::function和std::bind，使回调的实现更加灵活和类型安全。
函数指针方式的回调
这是最简单和最原始的实现方式。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
cpp
#include <iostream>
// 定义一个函数指针类型
typedef void (*CallbackFunc)(int);
void EventTrigger(CallbackFunc callback, int value) {
// 触发回调
callback(value);
}
void MyCallback(int data) {
std::cout << "Callback called with data: " << data << std::endl;
}
int main() {
EventTrigger(MyCallback, 42);
return 0;
}
仿函数方式的回调
仿函数是重载了 operator() 的类或者结构体。文章源自灵鲨社区-https://www.0s52.com/bcjc/cyyjc/17484.html
cpp
#include <iostream>
// 定义一个仿函数
struct MyCallback {
void operator()(int data) const {
std::cout << "Callback called with data: " << data << std::endl;
}
};
void EventTrigger(const MyCallback& callback, int value) {
callback(value);
}
int main() {
MyCallback myCallback;
EventTrigger(myCallback, 42);
return 0;
}
总结
仿函数在C++中是一个非常有用的工具，它们结合了类和函数的优点，能够携带状态，并且通过重载operator()实现灵活的函数调用。仿函数在STL（标准模板库）中被广泛应用，如在容器类中的std::sort等算法中，用来传递自定义的比较函数。
评论