跳到主要内容

C++ 算术函数对象

概述​

在C++ STL中，函数对象是一种行为类似函数的对象，它们是重载了operator()运算符的类的实例。算术函数对象是STL提供的一类特殊函数对象，专门用于执行基本的算术运算，如加法、减法、乘法和除法等。它们位于<functional>头文件中，使得我们可以将算术操作当作参数传递给其他函数或算法。

与普通函数相比，函数对象可以保存状态，更加灵活，并且往往能够获得更好的性能，因为编译器可以更好地对其进行内联优化。

基本算术函数对象​

STL提供了以下几种基本的算术函数对象：

  1. std::plus<T>：加法操作，等价于operator+
  2. std::minus<T>：减法操作，等价于operator-
  3. std::multiplies<T>：乘法操作，等价于operator*
  4. std::divides<T>：除法操作，等价于operator/
  5. std::modulus<T>：取模操作，等价于operator%
  6. std::negate<T>：取负操作，等价于一元operator-

每个函数对象都是一个模板类，可以针对不同的数据类型使用。

基本使用方法​

让我们先看一个简单的示例，展示如何使用这些算术函数对象：

#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结合，对容器中的元素求和：

#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中：

#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提供的标准算术函数对象，我们还可以自定义算术函数对象来满足特殊需求：

#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. 数据统计分析​

算术函数对象可以用于执行数据集合的统计分析，如计算平均值、标准差等：

#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. 自定义排序​

算术函数对象可用于自定义排序规则，例如按照学生成绩的降序排序：

#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. 并行计算​

在并行计算场景中，算术函数对象可以用作任务或操作的描述，方便地在不同线程间分配计算工作：

#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中非常实用的工具，它们提供了一种将算术运算符当作对象使用的方法，使代码更加灵活。主要优点包括：

  1. 可作为参数传递：可以将算术操作作为参数传递给其他函数或算法。
  2. 类型安全：提供类型检查，避免运行时错误。
  3. 可能的性能优势：编译器可以更好地对函数对象进行内联优化。
  4. 状态保存：与普通函数相比，函数对象可以保存状态。

在实际应用中，算术函数对象广泛应用于STL算法、容器操作、数据处理和并行计算等场景，是C++程序员必须掌握的重要工具之一。

练习​

  1. 使用std::transform和std::negate函数对象，将一个整数向量中的每个元素都变为其负值。
  2. 创建一个自定义算术函数对象，实现两个数之间的幂运算（如x^y）。
  3. 使用std::accumulate和适当的算术函数对象计算一个向量中所有元素的乘积。
  4. 实现一个使用算术函数对象的简单计算器，可以接受两个数和一个运算符，并返回计算结果。

更多资源​

通过学习和掌握算术函数对象，你将能够更加灵活地使用C++ STL，编写更简洁、高效的代码。