I have a class A and a < comparator. How can I use them to sort an array of A in descending order?
class A {
...
};
class LessA {
bool operator()(const A& a1, const A& a2) const {
...
}
}
vector<A> v;
sort(v.begin(), v.end(), ???);
I suppose I should replace the ??? with something based on LessA, but I can't figure out what should go in there. I thought of using a lambda function, but I was looking for something shorter.
If you want to sort according to the relation defined by your LessA comparator, just pass an instance of LessA as the third argument (and, since you are using C++11, prefer the global std::begin() and std::end() functions):
std::sort(std::begin(a), std::end(a), LessA());
// ^^^^^^^
Now if your LessA() expresses the < relation and you want to sort according to the opposite criterion, you could do:
std::sort(std::begin(a), std::end(a),
[] (A const& a1, A const& a2))
{
return LessA()(a2, a1);
}
Another thing you could do is to let your custom comparator accept an argument that determines how it should perform the comparison:
class CompA {
bool lessThan;
public:
CompA(bool lessThan) : _lessThan(lessThan) { }
bool operator()(const A& a1, const A& a2) const {
if (_lessThan)
{
// return true iff a1 < a2;
}
else
{
// return true iff a1 > a2;
}
}
};
You could then use it this way to sort in ascending order:
std::sort(std::begin(a), std::end(a), CompA(true));
And this way to sort in descending order:
std::sort(std::begin(a), std::end(a), CompA(false));
Another possibility, given your original LessA comparator, is to use std::bind to swap the order of the arguments to your custom comparator:
LessA comp;
using namespace std::placeholders;
std::sort(std::begin(v), std::end(v),
std::bind(&LessA::operator(), comp, _2, _1));
Sort the range backwards:
vector<A> v;
sort(v.rbegin(), v.rend(), LessA());
rbegin, and rend give you reverse iterators.
Encapsulate if it's too confusing:
void reverse_sort(vector<A>& v) {
sort(v.rbegin(), v.rend(), LessA());
}
Usage:
vector<A> v;
reverse_sort(v);
Use std::greater for the comparison functor. The default (std::less) will give you an ascending order; this will give you a descending order. (You'll need to add a using namespace std::rel_ops; (link) statement or explicitly define operator> as well.)
Taken from cppreference.com
#include <algorithm>
#include <functional>
#include <array>
#include <iostream>
int main()
{
std::array<int, 10> s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
// sort using the default operator<
std::sort(s.begin(), s.end());
for (int a : s) {
std::cout << a << " ";
}
std::cout << '\n';
// sort using a standard library compare function
std::sort(s.begin(), s.end(), std::greater<int>());
for (int a : s) {
std::cout << a << " ";
}
std::cout << '\n';
// sort using a custom functor
struct {
bool operator()(int a, int b)
{
return a < b;
}
} customLess;
std::sort(s.begin(), s.end(), customLess);
for (int a : s) {
std::cout << a << " ";
}
std::cout << '\n';
// sort using a lambda
std::sort(s.begin(), s.end(), [](int a, int b) {
return b < a;
});
for (int a : s) {
std::cout << a << " ";
}
std::cout << '\n';
}
Given a function lt(a, b) that implements a<b, you can create a function that implements a>=b by returning !lt(a, b). To implement >, you need to return !lt(b, a) && !(lt(a,b) || lt(b,a)).
lt(a, b) || lt(b, a) is equivalent to a!=b, so the above is equivalent to a>=b && a!=b which reduces to a>b.
However, you can probably get away with just std::not2(LessA()). That will sort with >= which will sort in descending order.
Make the () operator of the LessA class return !(a1 < a2) and pass it in like this:
std::sort(v.begin(), v.end(), LessA());
