C++ 算术函数对象
概述
在C++ STL中，函数对象是一种行为类似函数的对象，它们是重载了operator()运算符的类的实例。算术函数对象是STL提供的一类特殊函数对象，专门用于执行基本的算术运算，如加法、减法、乘法和除法等。它们位于<functional>头文件中，使得我们可以将算术操作当作参数传递给其他函数或算法。
与普通函数相比，函数对象可以保存状态，更加灵活，并且往往能够获得更好的性能，因为编译器可以更好地对其进行内联优化。
基本算术函数对象
STL提供了以下几种基本的算术函数对象：
std::plus<T>：加法操作，等价于operator+std::minus<T>：减法操作，等价于operator-std::multiplies<T>：乘法操作，等价于operator*std::divides<T>：除法操作，等价于operator/std::modulus<T>：取模操作，等价于operator%std::negate<T>：取负操作，等价于一元operator-
每个函数对象都是一个模板类，可以针对不同的数据类型使用。
基本使用方法
让我们先看一个简单的示例，展示如何使用这些算术函数对象：
cpp
#include <iostream>
#include <functional>
int main() {
// 声明函数对象
std::plus<int> add;
std::minus<int> subtract;
std::multiplies<int> multiply;
std::divides<int> divide;
std::modulus<int> modulo;
std::negate<int> negate;
// 使用函数对象
std::cout << "10 + 5 = " << add(10, 5) << std::endl;
std::cout << "10 - 5 = " << subtract(10, 5) << std::endl;
std::cout << "10 * 5 = " << multiply(10, 5) << std::endl;
std::cout << "10 / 5 = " << divide(10, 5) << std::endl;
std::cout << "10 % 3 = " << modulo(10, 3) << std::endl;
std::cout << "-(10) = " << negate(10) << std::endl;
return 0;
}
输出结果：
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2
10 % 3 = 1
-(10) = -10
备注
从C++14开始，这些函数对象模板还支持无模板参数的使用形式，例如std::plus<>()，这将允许编译器根据传入的参数自动推导类型。
与STL算法结合使用
算术函数对象最常见的应用是与STL的算法结合使用。例如，我们可以用std::plus<T>与std::accumulate结合，对容器中的元素求和：
cpp
#include <iostream>
#include <vector>
#include <numeric>
#include <functional>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
int sum = std::accumulate(numbers.begin(), numbers.end(), 0, std::plus<int>());
int product = std::accumulate(numbers.begin(), numbers.end(), 1, std::multiplies<int>());
std::cout << "Sum: " << sum << std::endl; // 输出: Sum: 15
std::cout << "Product: " << product << std::endl; // 输出: Product: 120
return 0;
}
与STL容器结合使用
算术函数对象也可以用作容器的比较器，例如在std::map或std::set中：
cpp
#include <iostream>
#include <set>
#include <functional>
int main() {
// 创建一个降序排列的集合
std::set<int, std::greater<int>> descendingSet;
descendingSet.insert(5);
descendingSet.insert(3);
descendingSet.insert(8);
descendingSet.insert(1);
std::cout << "Descending set: ";
for(int num : descendingSet) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
输出结果：
Descending set: 8 5 3 1
自定义算术函数对象
除了使用STL提供的标准算术函数对象，我们还可以自定义算术函数对象来满足特殊需求：
cpp
#include <iostream>
#include <vector>
#include <algorithm>
// 自定义算术函数对象，计算一个数的平方
class Square {
public:
int operator()(int x) const {
return x * x;
}
};
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> squares(numbers.size());
// 使用自定义函数对象计算每个元素的平方
std::transform(numbers.begin(), numbers.end(), squares.begin(), Square());
std::cout << "Squares: ";
for(int num : squares) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
输出结果：
Squares: 1 4 9 16 25
实际应用场景
1. 数据统计分析
算术函数对象可以用于执行数据集合的统计分析，如计算平均值、标准差等：
cpp
#include <iostream>
#include <vector>
#include <numeric>
#include <functional>
#include <cmath>
int main() {
std::vector<double> data = {5.0, 7.5, 3.2, 9.1, 4.8};
// 计算总和
double sum = std::accumulate(data.begin(), data.end(), 0.0);
// 计算平均值
double mean = sum / data.size();
// 计算各元素与平均值的差的平方和
double squaredDiffSum = 0.0;
for(double value : data) {
squaredDiffSum += std::pow(value - mean, 2);
}
// 计算标准差
double stdDev = std::sqrt(squaredDiffSum / data.size());
std::cout << "Mean: " << mean << std::endl;
std::cout << "Standard Deviation: " << stdDev << std::endl;
return 0;
}
2. 自定义排序
算术函数对象可用于自定义排序规则，例如按照学生成绩的降序排序：
cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <functional>
struct Student {
std::string name;
int score;
// 显示学生信息的方法
void display() const {
std::cout << name << ": " << score << std::endl;
}
};
int main() {
std::vector<Student> students = {
{"Alice", 85},
{"Bob", 92},
{"Charlie", 78},
{"David", 90}
};
// 使用greater函数对象按成绩降序排序
std::sort(students.begin(), students.end(),
[](const Student& a, const Student& b) {
return std::greater<int>()(a.score, b.score);
});
std::cout << "Students (sorted by score in descending order):" << std::endl;
for(const auto& student : students) {
student.display();
}
return 0;
}
3. 并行计算
在并行计算场景中，算术函数对象可以用作任务或操作的描述，方便地在不同线程间分配计算工作：
cpp
#include <iostream>
#include <vector>
#include <functional>
#include <thread>
#include <algorithm>
// 并行处理向量的函数
template<class T, class BinaryOp>
void parallel_process(std::vector<T>& result, const std::vector<T>& v1,
const std::vector<T>& v2, BinaryOp op) {
size_t num_threads = 4; // 假设使用4个线程
size_t chunk_size = result.size() / num_threads;
std::vector<std::thread> threads;
for (size_t i = 0; i < num_threads; ++i) {
size_t start = i * chunk_size;
size_t end = (i == num_threads - 1) ? result.size() : (i + 1) * chunk_size;
threads.emplace_back([&, start, end]() {
for (size_t j = start; j < end; ++j) {
result[j] = op(v1[j], v2[j]);
}
});
}
// 等待所有线程完成
for (auto& thread : threads) {
if (thread.joinable()) {
thread.join();
}
}
}
int main() {
std::vector<int> v1 = {1, 2, 3, 4, 5, 6, 7, 8};
std::vector<int> v2 = {10, 20, 30, 40, 50, 60, 70, 80};
std::vector<int> result(v1.size());
// 并行计算两个向量的和
parallel_process(result, v1, v2, std::plus<int>());
std::cout << "Vector sum: ";
for(int num : result) {
std::cout << num << " ";
}
std::cout << std::endl;
// 并行计算两个向量的乘积
parallel_process(result, v1, v2, std::multiplies<int>());
std::cout << "Vector product: ";
for(int num : result) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
总结
算术函数对象是C++ STL中非常实用的工具，它们提供了一种将算术运算符当作对象使用的方法，使代码更加灵活。主要优点包括：
- 可作为参数传递：可以将算术操作作为参数传递给其他函数或算法。
- 类型安全：提供类型检查，避免运行时错误。
- 可能的性能优势：编译器可以更好地对函数对象进行内联优化。
- 状态保存：与普通函数相比，函数对象可以保存状态。
在实际应用中，算术函数对象广泛应用于STL算法、容器操作、数据处理和并行计算等场景，是C++程序员必须掌握的重要工具之一。
练习
- 使用
std::transform和std::negate函数对象，将一个整数向量中的每个元素都变为其负值。 - 创建一个自定义算术函数对象，实现两个数之间的幂运算（如x^y）。
- 使用
std::accumulate和适当的算术函数对象计算一个向量中所有元素的乘积。 - 实现一个使用算术函数对象的简单计算器，可以接受两个数和一个运算符，并返回计算结果。
更多资源
通过学习和掌握算术函数对象，你将能够更加灵活地使用C++ STL，编写更简洁、高效的代码。