структурированные привязки с std::minmax и rvalues

Что важно отметить в auto [amin, amax], так это то, что auto, auto& и т. д. применяются к составленному объекту e, который инициализируется с возвращаемым значением std::minmax, которое является парой. По сути это:

auto e = std::minmax(3, 6);

auto&& amin = std::get<0>(e);
auto&& amax = std::get<1>(e);

Фактические типы amin и amax являются ссылками, которые относятся к тому, что возвращают std::get<0> и std::get<1> для этого парного объекта. И сами возвращают ссылки на давно исчезнувшие объекты!

Когда вы используете std::tie, вы выполняете присваивание существующим объектам (передаются по ссылке). rvalue не должны жить дольше, чем выражения присваивания, в которых они возникают.

В качестве обходного пути вы можете использовать что-то вроде этой функции (не качества производства):

template<typename T1, typename T2>
auto as_value(std::pair<T1, T2> in) {
    using U1 = std::decay_t<T1>;
    using U2 = std::decay_t<T2>;
    return std::pair<U1, U2>(in);
}

Это гарантирует, что пара содержит типы значений. При использовании следующим образом:

auto [amin, amax] = as_value(std::minmax(3, 6));

Теперь мы делаем копию, и структурированные привязки ссылаются на эти копии.

Здесь возникают две фундаментальные проблемы:

1. min, max и minmax по историческим причинам возвращают ссылки. Так что если вы передаете временную, лучше брать результат по значению или сразу использовать, иначе получите висячую ссылку. Если бы minmax поставил вам здесь pair<int, int> вместо pair<int const&, int const&>, у вас не было бы никаких проблем.
2. auto уничтожает cv-квалификаторы верхнего уровня и удаляет ссылки, но не удаляет их полностью. Здесь вы выводите это pair<int const&, int const&>, но если бы мы вывели pair<int, int>, у нас снова не было бы никаких проблем.

(1) гораздо проще решить проблему, чем (2): напишите свои собственные функции, чтобы принимать все по значению:

template <typename T>
std::pair<T, T> minmax(T a, T b) {
    return (b < a) ? std::pair(b, a) : std::pair(a, b);
}

auto [amin, amax] = minmax(3, 6); // no problems

Хорошая вещь в том, чтобы принимать все по значению, заключается в том, что вам никогда не придется беспокоиться о скрытых оборванных ссылках, потому что их нет. И подавляющее большинство применений этих функций в любом случае используют целочисленные типы, поэтому от ссылок нет никакой пользы.

А когда вам действительно нужны ссылки, например, когда вы сравниваете дорогостоящие объекты... ну, проще взять функцию, которая принимает значения, и заставить ее использовать ссылки, чем возьмите функцию, которая использует ссылки, и попытайтесь ее исправить:

auto [lo, hi] = minmax(std::ref(big1), std::ref(big2)); 

Кроме того, здесь, на сайте вызова, очень хорошо видно, что мы используем ссылки, поэтому было бы гораздо более очевидно, если бы мы ошиблись.

Хотя приведенное выше работает для многих типов из-за неявного преобразования reference_wrapper<T> в T&, оно не будет работать для тех типов, у которых есть шаблоны операторов, не являющихся членами, не являющимися друзьями (например, std::string). Так что, к сожалению, вам нужно будет дополнительно написать специализацию для эталонных оберток.