Home/ Questions/Q 874123
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-15T11:03:22+00:00

The min algorithm is normally expressed like this: template <typename T> const T& min(const

  • 0

The min algorithm is normally expressed like this:

template <typename T>
const T& min(const T& x, const T& y)
{
    return y < x ? y : x;
}

However, this does not allow constructs of the form min(a, b) = 0. You can achieve that with an additional overload:

template <typename T>
T& min(T& x, T& y)
{
    return y < x ? y : x;
}

What I would like to do is unify these two overloads via perfect forwarding:

template <typename T>
T&& min(T&& x, T&& y)
{
    return y < x ? std::forward<T>(y) : std::forward<T>(x);
}

However, g++ 4.5.0 spits out a warning for min(2, 4) that I return a reference to a temporary. Did I do something wrong?

Okay, I get it. The problem is with the conditional operator. In my first solution, if I call min(2, 4) the conditional operator sees an xvalue and thus moves from the forwarded x to produce a temporary object. Of course it would be dangerous to return that by reference! If I forward the whole expression instead of x and y seperately, the compiler does not complain anymore:

template <typename T>
T&& min(T&& x, T&& y)
{
    return std::forward<T>(y < x ? y : x);
}

Okay, I got rid of the references for arithmetic types 🙂

#include <type_traits>

template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
min(T x, T y)
{
    return y < x ? y : x;
}

template <typename T>
typename std::enable_if<!std::is_arithmetic<T>::value, T&&>::type
min(T&& x, T&& y)
{
    return std::forward<T>(y < x ? y : x);
}
Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    It looks to me like you’re trying to oversimplify the problem. Unfortunately, getting it entirely correct is decidedly non-trivial. If you haven’t read N2199, now would be a good time to do so. Rvalue references continue to evolve, so its reference implementation of min and max probably isn’t exactly right anymore, but it should at least be a pretty decent starting point. Warning: the reference implementation is a lot more complex than you’re going to like!

    • 0