Mfcttrf

std::tie(a, b) = std::minmax(a, b);

I think this is intuitive code. Clean and understandable. Too bad it doesn't work as intended, as std::minmax templates for const&. If therefore the values are swapped inside the std::pair<const&, const&> than one assignement will overwrite the other value:

auto[a, b] = std::make_pair(7, 5);
std::tie(a, b) = std::minmax(a, b);
std::cout << "a: " << a << ", b: " << b << 'n';

a: 5, b: 5

The expected output here is a: 5, b: 7.

I think this is important as implementing transform functions to apply a function onto some ranges requires such statements for intuitive lambdas. For example:

std::vector<int> v 0, 1, 0, 2, 0 ;
std::vector<int> u 1, 0, 1, 0, 1 ;

perform(v.begin(), v.end(), u.begin(), [](auto& a, auto& b) 
 std::tie(a, b) = std::minmax(a, b); 
); 

//v would be == 0, 0, 0, 0, 0
//u would be == 1, 1, 1, 2, 1

One solution I found was constructing a std::tuple explicitly without any reference qualifiers over the std::pair<const&, const&> to enforce a copy:

std::tie(a, b) = std::tuple<int, int>(std::minmax(a, b)); 

But this <int, int> redundancy seems rather awful, especially when having saidauto& a, auto& b before.

Is there a nice, short way to perform this assignement? Could it be that this is the wrong direction and just saying if (a >= b) std::swap(a, b); would be the best approach here?

You can use an initializer list for minmax:

std::tie(a, b) = std::minmax(a, b);

This causes temporary objects to be created (just like when using unary +) but it has the benefit that it works with types that is lacking unary +.

using namespace std::string_view_literals;

auto [a, b] = std::make_pair("foo"sv, "bar"sv);
std::tie(a, b) = std::minmax(a, b);
std::cout << "a: " << a << ", b: " << b << 'n';

Output:

a: bar, b: foo

You can enforce this with a certain level of brevity as follows.

std::tie(a, b) = std::minmax(+a, +b);

std::cout << "a: " << a << ", b: " << b << 'n';

Explanation: the builtin unary plus operator, for the sake of symmetry with its unary minus sibling, returns its operand by value (it also performs the usual arithmetic conversions, but that doesn't apply to ints). This means it has to create a temporary, even though this temporary is nothing but a copy of the operand. But for the usage of minmax in this example, it's sufficient: swapping references here doesn't assign through anymore, because the references on the right hand side (the const int& arguments passed to minmax) don't refer to the same objects as those on the left hand side (inside the tuple of references created by std::tie).

The output is as desired:

a: 5, b: 7