How to extend STL algorithms using C++ function objects?

STL algorithms can be extended by using function objects, which are classes or structures with call operators (operator()). You only need to pass the function object as a parameter of the algorithm. For example, when using the std::sort algorithm to sort containers, you can pass the std::greater function object as the comparison function. The function object allows us to customize the STL algorithm to achieve more flexible requirements, such as customizing the summation function to apply the exponential function to the sum of elements. Using the ExpSum function object can convert 1^2 2^2 3^2 4^2 The result (30) is passed to the std::accumulate algorithm for accumulation.

How to extend STL algorithms using C function objects?

C The Standard Template Library (STL) provides many powerful algorithms for easily and efficiently processing data collections. However, sometimes we need to customize these algorithms to meet our specific needs. C function objects allow us to easily extend STL algorithms to achieve this customization.

Function Object

A function object is a class or structure that has a call operator (operator()). By calling a function object, you can perform some operations just like calling a normal function.

Extending the STL algorithm

• Extending the STL algorithm using a function object is very simple, just pass the function object as one of the parameters of the algorithm.
• For example, to sort a container using a custom comparison function, we can use the std::sort algorithm and pass the std::greater function object as a comparison function.

std::vector<int> vec = {3, 1, 2, 4};
std::sort(vec.begin(), vec.end(), std::greater<>{});

• Output: [4, 3, 2, 1]

Practical case: Custom summation function

The following practical example shows how to use a function object to customize the std::accumulate algorithm to calculate the sum of elements in a container and apply an exponential function:

struct ExpSum {
    int operator()(int a, int b) const {
        return a + std::pow(b, 2);
    }
};

int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    int sum = std::accumulate(vec.begin(), vec.end(), 0, ExpSum{});
    std::cout << sum << std::endl;  // 输出：30（1^2 + 2^2 + 3^2 + 4^2）
}

With this approach we are able to integrate custom logic into the STL algorithm, thereby increasing flexibility and meeting our specific requirements.

The above is the detailed content of How to extend STL algorithms using C++ function objects?. For more information, please follow other related articles on the PHP Chinese website!