Is there a way to easily handle functions returning std::pairs?

Question

C++11 has function std::minmax_element which returns a pair of values. This, however, is quite confusing to handle and read, and produces an extra, later useless variable to pollute the scope.

auto lhsMinmax = std::minmax_element(lhs.begin(), lhs.end());
int &lhsMin = *(lhsMinMax.first);
int &lhsMax = *(lhsMinmax.second);

Is there a better way to do this? Something like:

int lhsMin;
int lhsMax;
std::make_pair<int&, int&>(lhsMin, lhsMax).swap(
    std::minmax_element(lhs.begin(), lhs.end()));

Answer 1

With structured binding from C++17, you may directly do

auto [lhsMinIt, lhsMaxIt] = std::minmax_element(lhs.begin(), lhs.end());

Answer 2

To avoid polluting your scope, you could enclose the assignment in a smaller scope:

int lhsMin, lhsMax;

{
    auto it = std::minmax_element(lhs.begin(), lhs.end());
    lhsMin = *it.first;
    lhsMax = *it.second;
}

alternatively, you can use a lambda

int lhsMin, lhsMax;

std::tie(lhsMin, lhsMax) = [&]{
    auto it = std::minmax_element(lhs.begin(), lhs.end());
    return std::make_tuple(*it.first, *it.second);
}();

Answer 3

This looks like enough of a common case to prompt a helper function:

template <class T, std::size_t...Idx>
auto deref_impl(T &&tuple, std::index_sequence<Idx...>) {
    return std::tuple<decltype(*std::get<Idx>(std::forward<T>(tuple)))...>(*std::get<Idx>(std::forward<T>(tuple))...);
}

template <class T>
auto deref(T &&tuple)
    -> decltype(deref_impl(std::forward<T>(tuple), std::make_index_sequence<std::tuple_size<std::remove_reference_t<T>>::value>{})) {
    return deref_impl(std::forward<T>(tuple), std::make_index_sequence<std::tuple_size<std::remove_reference_t<T>>::value>{});
}

// ...

int lhsMin;
int lhsMax;
std::tie(lhsMin,lhsMax) = deref(std::minmax_element(lhs.begin(), lhs.end()));

index_sequence is C++14, but a full implementation can be made in C++11.

Note: I'd keep the repeated decltype in deref's return type even in C++14, so that SFINAE can apply.

See it live on Coliru

Answer 4

I'd just be more direct and write my own version of minmax_element:

template <class Iter, class R = typename iterator_traits<Iter>::reference>
std::pair<R,R> deref_minmax(Iter first, Iter last)
{
    auto iters = std::minmax_element(first, last);
    return std::pair<R,R>{*iters.first, *iters.second};
}

Which is then just:

int lo, hi;
std::tie(lo, hi) = deref_minmax(lhs.begin(), lhs.end());

This would limit you to just a single copy of the elements (which isn't that much of a big deal with ints), also let you maintain access to the references into the actual container.

---

In C++17, for fun, we could write a generalized dereferencer:

template <class Tuple>
auto deref(Tuple&& tup) {
    return std::apply([](auto... args) {
        return std::tuple <decltype(*args)...>(*args...);
    }, tup);
}

auto& [lo, hi] = deref(std::minmax_element(lhs.begin(), lhs.end()));

Here lo and hi are references into the container itself.

Answer 5

There's no way of assigning two references at once in the current revision of the standard, if that's what you are after. Note that none of the other answers do that, except Barry's which requires C++17 and a helper template.

However, if you want a read-write access to your minimal and maximal elements, why not just go with the iterators the minmax_element provides you directly? It's likely to generate identical machine code as using references anyway, at least if your lhs is a ContiguousContainer but maybe in other cases as well.

You will need to rely a bit less on the automatic type deduction, for example,

decltype(lhs.begin()) lhsMinIt, lhsMaxIt;
std::tie(lhsMinIt, lhsMaxIt) = std::minmax_element(lhs.begin(), lhs.end());
/* now access your minimum and maximum as *lhsMinIt and *lhsMaxIt */

If you know the type of lhs will be one of the standard containers, you can use a bit cleaner type designation decltype(lhs)::iterator.

Answer 6

In C++14 or greater

template<class=void, std::size_t...Is>
auto indexer( std::index_sequence<Is...> ) {
  return [](auto&&f){
    return f( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto indexer() {
  return indexer( std::make_index_sequence<N>{} );
}
template<class F>
auto fmap_over_tuple( F&& f ) {
  return [f=std::forward<F>(f)](auto&& tuple) {
    using Tuple = decltype(tuple);
    using Tuple_d = std::decay_t<Tuple>;
    auto index = indexer< std::tuple_size< Tuple_d >::value >();
    return index(
      [&f, &tuple](auto&&...Is) {
        using std::get;
        return std::make_tuple(
          f( get<Is>( std::forward<Tuple>(tuple) ) )...
        );
      }
    );
  };
}

so fmap_over_tuple takes a function object. It returns a function object that, when passed a tuple-like, proceeds to call the function object on each element of the tuple-like, and generate a tuple from it.

We then write dereference tuple:

auto dereference_tuple = fmap_over_tuple(
  [](auto&& e) { return *e; }
);

Now in C++17 we do:

auto[Min, Max] = dereference_tuple( std::minmax_element(lhs.begin(), lhs.end() );

and bob is your uncle.

In C++11, just do what you did. Clean enough.

C++14 live example.