How do generic algorithms in C++ reuse functions?

C++ Generic algorithms can reuse common operations, including: sorting algorithms (such as sort) search algorithms (such as find) set operations (such as set_difference) conversion algorithms (such as transform) When using generic algorithms, you need to provide an input container, Output container (optional) and function object as parameters. For example, the sort algorithm can be used to sort arrays of integers. Custom comparators can be used to sort data according to specific rules. In practical cases, the std::max_element algorithm can be used to find the maximum value in a container, improving code simplicity and maintainability.

C++ Generic Algorithm: A powerful tool for reusing code

The C++ standard library provides powerful generic algorithms to make programs Developers can reuse common operations without having to rewrite code. These algorithms are provided as templates and can be applied to various data types.

Algorithm categories

The generic algorithms in the standard library can be divided into several categories:

• Sort algorithms (such as sort and stable_sort)
• Search algorithms (such as find and binary_search)
• Set operations (such as set_difference and set_intersection)
• Transformation algorithms (such as transform and copy)

How to use

Using generic algorithms is very simple. Just pass an input container, an output container (if needed), and a function object as arguments.

For example, the following code uses the sort algorithm to sort an array of integers:

#include <algorithm>

int main() {
  int myArray[] = {4, 1, 3, 2};
  std::sort(std::begin(myArray), std::end(myArray));

  for (int i : myArray) {
    std::cout << i << " ";  // 输出：1 2 3 4
  }
}

Custom comparator

For those who need When customizing a comparator for sorting, you can use the Comparator parameter of the generic algorithm std::sort.

For example, the following code uses a lambda expression to define a custom comparator to sort numbers in reverse order:

#include <algorithm>

int main() {
  int myArray[] = {4, 1, 3, 2};
  std::sort(std::begin(myArray), std::end(myArray), [](int a, int b) { return a > b; });

  for (int i : myArray) {
    std::cout << i << " ";  // 输出：4 3 2 1
  }
}

Practical example: Find the maximum value

Suppose we have a list of student grades and need to find the maximum value. We can use the std::max_element algorithm:

#include <algorithm>
#include <vector>

int main() {
  std::vector<int> scores = {85, 90, 78, 95, 82};
  int maxScore = *std::max_element(scores.begin(), scores.end());
  std::cout << "最高分：" << maxScore;  // 输出：95
}

By utilizing the generic algorithm, we do not have to write our own maximum function to find, but can reuse the code in the standard library, which Improved code simplicity and maintainability.

The above is the detailed content of How do generic algorithms in C++ reuse functions?. For more information, please follow other related articles on the PHP Chinese website!