An explicit cast for narrowing numeric conversions

Question

Inspired by gsl::narrow_cast, I created my own implementation with the addition of a couple of features:

• a static assert on the types to ensure the cast is actually narrowing (if future changes to the code mean the cast is no longer narrowing, we don't want to still have a narrow_cast there)
• the version without a runtime check still has an assert, so it's checked in debug mode

#include <cassert>
#include <exception>
#include <iostream>
#include <type_traits>

namespace details {

template <typename T, typename U>
constexpr bool is_same_signedness = std::is_signed<T>::value == std::is_signed<U>::value;

template <typename T, typename U>
constexpr bool can_fully_represent =
    std::is_same<T, U>::value ||
    ( std::is_integral<T>::value && std::is_integral<U>::value &&
        ( ( std::is_signed<T>::value && sizeof(T) >  sizeof(U) ) ||
          ( is_same_signedness<T, U> && sizeof(T) >= sizeof(U) ) ) ) ||
    ( std::is_floating_point<T>::value && std::is_floating_point<U>::value && sizeof(T) >= sizeof(U) );

template <typename T, typename U>
constexpr bool static_cast_changes_value(U u) noexcept
{
    const auto t = static_cast<T>(u);

    // this should catch most cases, but may miss dodgy unsigned to signed conversion or vice-versa
    if (static_cast<U>(t) != u)
        return true;

    if (std::is_signed<T>::value != std::is_signed<U>::value && ((t < T{}) != (u < U{})))
        return true;

    return false;
}

} // namespace details

// TODO: unchecked cast for types where some loss of precision (and therefore assertion failure) is expected?
template <typename T, typename U>
constexpr T narrow_cast(U&& u) noexcept
{
    static_assert(!details::can_fully_represent<T, U>, "we shouldn't be using narrow_cast for casts that aren't actually narrowing");
    assert(!details::static_cast_changes_value<T>(u));
    return static_cast<T>(std::forward<U>(u));
}

struct narrowing_error : public std::exception {};

template <typename T, typename U>
constexpr T narrow_cast_checked(U u)
{
    static_assert(!details::can_fully_represent<T, U>, "we shouldn't be using narrow_cast for casts that aren't actually narrowing");
    if (details::static_cast_changes_value<T>(u))
        throw narrowing_error();

    return static_cast<T>(u);
}

Answer 1

The first thing I noticed: you only support basic arithmetic types (integral and floating point). This isn't apparent from the name narrow_cast. Either enforce this with a static assert, or provide a mechanism to provide extensions for user defined types.

Here's what you write:

template <typename T, typename U>
constexpr bool can_fully_represent =
    std::is_same<T, U>::value ||
    ( std::is_integral<T>::value && std::is_integral<U>::value &&
        ( ( std::is_signed<T>::value && sizeof(T) >  sizeof(U) ) ||
          ( is_same_signedness<T, U> && sizeof(T) >= sizeof(U) ) ) ) ||
    ( std::is_floating_point<T>::value && std::is_floating_point<U>::value && sizeof(T) >= sizeof(U) );

Here's what I think should be sufficient:

template <typename T, typename U>
constexpr bool can_fully_represent =
       std::numeric_limits<T>::min() <= std::numeric_limits<U>::min()
    && std::numeric_limits<T>::max() >= std::numeric_limits<U>::max();

OK, maybe I overlooked some edge cases, but that's the idea.

The unchecked version uses a forwarding reference, whereas the check version does not. Try to keep the interface consistent.

std::is_same<T, U>::value can be simplified to std::is_same_v<T, U>.