So far, we’ve written sort comparison functions on the assumption that we want to sort all keys ascending. But what if you want a mix of ascending and descending?<\/p>\n
Unfortunately, If you just want a straight descending sort across all columns, then you can flip the direction of the top-level comparison. For example, suppose we want to sort by height descending, then width descending:<\/p>\n However, it is more likely the case that you want a mix of ascending and descending. For example, you might want descending by height, then ascending by name.<\/p>\n Well, if the thing being sorted descending has a natural way of reversing the order, you can apply that reversal. For example, Boolean values can be For unsigned integers, bitwise negation works at reversing the sort order. And in fact, for two’s complement signed integers, bitwise negation will reverse the sort order as well. So we can use<\/p>\n However, for most types, there is no obvious “reversal” transformation on the data. You’ll have to reverse the comparison itself.<\/p>\n It’s important that you leave a comment explaining that the I don’t see any easy way to create a “reverse-comparison” wrapper, so I’ll make my own:<\/p>\n There are a few tricks here.<\/p>\n First, we implement only the spaceship operator, and let the compiler autogenerate the other comparison operators from it.<\/p>\n Second, we use Third, we use We can wrap a value inside a Unfortunately, I still see Bonus chatter<\/b>: It’s also easy to overlook the need to wrap the field in a std::tuple<\/code> does straight lexicographic ordering, so all the elements are sorted ascending. To get it to do descending sort, you’ll have to do something clever.<\/p>\nvoid f(std::vector<T>& v)\r\n{\r\n auto key = [](auto&& t) {\r\n return std::make_tuple(t.height, t.width);\r\n };\r\n std::sort(v.begin(), v.end(), [key](auto&& t, auto&& b) {\r\n \/\/ reversed comparison for descending sort<\/span>\r\n return key(a) ><\/span> key(b);\r\n });\r\n}\r\n<\/pre>\n!<\/code>‘ed, and signed integers can be negated, assuming they aren’t the most-negative two’s complement integer.<\/p>\nvoid f(std::vector<T>& v)\r\n{\r\n auto key = [](auto&& t) {\r\n \/\/ ascending by height, descending by width\r\n return std::make_tuple(t.height, -t.width);<\/span>\r\n };\r\n std::sort(v.begin(), v.end(), [key](auto&& t, auto&& b) {\r\n return key(a) < key(b);\r\n });\r\n}\r\n<\/pre>\nvoid f(std::vector<T>& v)\r\n{\r\n auto key = [](auto&& t) {\r\n \/\/ ascending by height, descending by width\r\n return std::make_tuple(t.height, ~<\/span>t.width);\r\n \/\/ ^\r\n };\r\n std::sort(v.begin(), v.end(), [key](auto&& t, auto&& b) {\r\n return key(a) < key(b);\r\n });\r\n}\r\n<\/pre>\nstd::weak_ordering\r\ncompare_3way_for_sorting(T const& a, T const& b)\r\n{\r\n auto cmp = std::compare_weak_order_fallback(a.name, b.name);\r\n \/\/ descending by connector (note that \"a\" and \"b\" are reversed)<\/span>\r\n if (cmp == 0) cmp = std::compare_weak_order_fallback(b.GetConnector(), a.GetConnector()<\/span>);\r\n if (cmp == 0) cmp = std::compare_weak_order_fallback(LookupManufacturingDate(a.part_number),\r\n LookupManufacturingDate(b.part_number));\r\n return cmp;\r\n}\r\n<\/pre>\na<\/code> and b<\/code> are reversed: The reversal is easily overlooked, so somebody looking at the code may not realize that we are sorting descending by connector, and somebody copying the code may not realize it either. And for readers who do notice it, you need the comment so that they don’t think the reversal is a bug and try to “fix” it.<\/p>\ntemplate<typename T>\r\nstruct descending_compare\r\n{\r\n descending_compare(T t) : value(std::move(t)) { }\r\n T value;\r\n\r\n auto operator<=>(descending_compare const& other) const {\r\n return std::compare_weak_order_fallback(other.comparand(), comparand());\r\n }\r\n std::unwrap_reference_t<T> const& comparand() const {\r\n return value;\r\n }\r\n};\r\n<\/pre>\nstd::unwrap_std::reference_descending_reference_reference_T<\/code>. But the C++ language rule for conversion chains allows only one user-defined conversion in the chain.<\/p>\ndescending_void f(std::vector<T>& v)\r\n{\r\n auto key = [](auto&& t) {\r\n \/\/ ascending by height, descending by area, descending by name\r\n return std::make_tuple(\r\n t.height,\r\n descending_compare(t.height * t.width),\r\n descending_compare(std::ref(t.name))<\/span>);\r\n };\r\n std::sort(v.begin(), v.end(), [key](auto&& a, auto&& b) {\r\n return key(a) < key(b);\r\n });\r\n}\r\n<\/pre>\nt.name<\/code>‘s <=><\/code> operator being called twice, so this still isn’t as good as I hoped. Maybe somebody can spot what I’m doing wrong. (I think it has to do with how I declared the spaceship operator. The compiler doesn’t realize that the descending_compare<\/code> is three-way comparable, so it falls back to doing two two-way comparisons.)<\/p>\nstd::ref<\/code> to suppress a copy. We could have a separate descending_field<\/code> wrapper for sorting fields descending.<\/p>\ntemplate<typename T>\r\nstruct descending_field :\r\n dscending_compare<std::reference_wrapper<T const>>\r\n{\r\n descending_field(T const& f) :\r\n descending_compare<std::reference_wrapper<T const>>(std::ref(f)) {}\r\n};\r\n<\/pre>\n