Ygtjki

A lot of algorithms accept a comparison object. Often, I end up with something like

std::sort(begin, end, [&](auto const& lhs, auto const& rhs) 
 return Function(lhs) < Function(rhs);
);

Is there anything in the STL to apply a Function before calling less than? So I could write:

std::sort(begin, end, std::DoesThisExist(Function));

I know I could write my own, but I wonder if this already exists. I glanced through cpprefence but didn't see it. Could easily have missed it.

The STL should have a sort that works on a transform of the elements rather than the elements themselves. The reason for this being that Function could actually be costly. By simply incorporating it into the comparison as you did you invoke Function nlog(n) times rather than the optimal n.

To sort arrays in parallel using STL algorithm :

std::sort(std::execution::par, container.begin(), container.end(), comparison_object);

Anyway, I think if you try to just sort with ranges::view::transform it will probably still call your function ~n log n many times. But you could just do something like:

auto values = /* some container */;
auto keys = values | ranges::view::transform(f) | ranges::to_vector;
ranges::sort(ranges::view::zip(keys, values),
 [](auto const& x, auto const& y) return std::get<0>(x) < std::get<0>(y); );

The Ranges TS (which has been merged for C++20) defines variations of many of the standard algorithms that include projections with exactly this behavior.

In principle, you could use std::bind, but it is very verbose:

 typedef std::remove_reference<decltype(*begin)>::type T;
 std::sort(begin, end, std::bind(std::less<T>(),
 std::bind(Function,std::placeholders::_1),
 std::bind(Function,std::placeholders::_2)));