When working with collections of data, sorting is a common operation. In C++, the standard library provides std::sort function to sort elements in ascending order based on the default comparison operator. However, there might be cases where we have custom sorting requirements that go beyond the default behavior.
Custom Sorting using Function Objects
C++ allows us to define custom sorting criteria using function objects. A function object is a class that defines the operator() function. By overloading this operator, we can use an instance of the function object to define our custom sorting behavior.
Let’s consider an example where we want to sort a collection of strings based on their length in descending order.
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
// Function object to define custom sorting behavior
struct StringLengthComparator {
bool operator()(const std::string& s1, const std::string& s2) const {
return s1.length() > s2.length();
}
};
int main() {
std::vector<std::string> strings = { "apple", "banana", "cherry", "date" };
std::sort(strings.begin(), strings.end(), StringLengthComparator());
for (const auto& str : strings) {
std::cout << str << " ";
}
return 0;
}
In the above code, we define a function object StringLengthComparator which compares two strings based on their length. The operator() function returns true if the length of the first string is greater than the length of the second string, indicating that the first string should come before the second in the sorted sequence.
We use this function object as the third argument to std::sort function to perform the sorting operation. The resulting sorted vector of strings is then printed to the console.
Custom Sorting using Lambda Functions
In addition to function objects, C++ also allows us to define custom sorting criteria using lambda functions, which are anonymous functions defined inline.
Using the previous example, we can rewrite the code using a lambda function instead of a function object:
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
int main() {
std::vector<std::string> strings = { "apple", "banana", "cherry", "date" };
std::sort(strings.begin(), strings.end(),
[](const std::string& s1, const std::string& s2) {
return s1.length() > s2.length();
});
for (const auto& str : strings) {
std::cout << str << " ";
}
return 0;
}
In this code snippet, we define a lambda function as the third argument to std::sort function. The lambda function compares two strings based on their length, same as before.
Using lambda functions can provide a more concise and readable way to define custom sorting criteria, especially for simple cases.
Conclusion
In C++, custom sorting can be achieved by defining custom comparison criteria using function objects or lambda functions. This allows us to sort elements in a way that suits our specific needs beyond the default behavior of the standard std::sort function.
By utilizing these techniques, we can efficiently sort the elements in a collection based on custom sorting literals and create more versatile and tailored sorting algorithms.
References: