c++ - 使用 C++ type_traits 避免缩小转换

Question

我有很多地方希望使用 std::enable_if 仅当从模板类型 A 到模板类型的简单静态转换时才允许某些模板B(两者都是数字)不会导致任何数据丢失。但是，我不确定我应该使用哪些现有类型特征(如果有的话)，或者我是否应该自己编写。

例如，从 uint16_t 转换为 uint32_t，从 float 转换为 double，甚至从 int 到 double 不会丢失任何精度或负号。但是从 double 转换为 int 或从 int 转换为 uint32_t 显然会有问题。

我做了一些测试，测试了 std::is_trivially_constructible、std::is_assignable、std::is_constructible 等.但是如果我尝试从 float 转到 int，我没有看到会警告我的。

我是否遗漏了当前库中的某些内容，还是我应该自己编写？

(我已经知道怎么写了。很简单。只是想确保我没有重新发明轮子)。

Answer 1

我正在回答我自己的问题，因为有人要求我发布我的特征，而评论似乎没有格式。

template <class T, class F>
struct is_safe_numeric_conversion 
    : pred_base <( ( ( ( std::is_integral<T>::value && std::is_integral<F>::value ) || ( std::is_floating_point<T>::value && std::is_floating_point<F>::value ) ) &&
                     sizeof(T) >= sizeof(F) ) ||
                     ( std::is_floating_point<T>::value && std::is_integral<F>::value ) ) &&
                 ( ( std::is_signed<T>::value && std::is_signed<F>::value ) || ( std::is_unsigned<T>::value && std::is_unsigned<F>::value ) )>
{
};

关于我为什么做我在这里所做的一些注释:

• 我最终使用 sizeof 来检查类型的实际大小，而不是 numeric_limits::max/lowest。我不喜欢那样，并且更愿意使用 numeric_limits，但 Visual C++ 使我对此感到不适应。我想知道这可能是因为他们的 constexpr 实现在我使用的某些版本中不起作用。
• 我使用自己的小“pred_base”只是为了让事情不那么冗长。我意识到我可以为此使用 integral_constant
• 就在今天，我意识到这不允许从小型无符号类型(比如 uint8_t)到大型有符号有符号类型(比如 int64_t)的有效转换，即使后者可以轻松保存前者的所有可能值。我需要解决这个问题，但它很小，在这一点上，我想我是唯一对此感兴趣的人......

最终版本(2018 年 2 月 3 日编辑)

StackOverflow 告诉我，今天有人为此给了我分数。所以我猜人们可能真的在使用它。在那种情况下，我想我应该展示我的整个当前版本，它解决了我上面提到的缺陷。

我确信有更好的方法可以做到这一点，而且我知道 C++14/17/etc 允许我更轻松地做到这一点，但我被迫在 VS 版本上一直工作到 VS2012所以我无法利用别名模板等。

因此，我通过编写一些辅助特征来做到这一点，然后从中组合出我最终的“is_safe_numeric_cast”特征。我认为它使事情更具可读性。

// pred_base selects the appropriate base type (true_type or false_type) to
// make defining our own predicates easier.

template<bool> struct pred_base : std::false_type {};
template<>     struct pred_base<true> : std::true_type {};

// same_decayed
// -------------
// Are the decayed versions of "T" and "O" the same basic type?
// Gets around the fact that std::is_same will treat, say "bool" and "bool&" as
// different types and using std::decay all over the place gets really verbose

template <class T, class O>
struct same_decayed 
    : pred_base <std::is_same<typename std::decay<T>::type, typename std::decay<O>::type>::value>
{};


// is_numeric.  Is it a number?  i.e. true for floats and integrals but not bool

template<class T>
struct is_numeric
    : pred_base<std::is_arithmetic<T>::value && !same_decayed<bool, T>::value>
{
};


// both - less verbose way to determine if TWO types both meet a single predicate

template<class A, class B, template<typename> class PRED>
struct both
    : pred_base<PRED<A>::value && PRED<B>::value>
{
};

// Some simple typedefs of both (above) for common conditions

template<class A, class B> struct both_numeric  : both<A, B, is_numeric>                { };    // Are both A and B numeric        types?
template<class A, class B> struct both_floating : both<A, B, std::is_floating_point>    { };    // Are both A and B floating point types?
template<class A, class B> struct both_integral : both<A, B, std::is_integral>          { };    // Are both A and B integral       types
template<class A, class B> struct both_signed   : both<A, B, std::is_signed>            { };    // Are both A and B signed         types
template<class A, class B> struct both_unsigned : both<A, B, std::is_unsigned>          { };    // Are both A and B unsigned       types


// Returns true if both number types are signed or both are unsigned
template<class T, class F>
struct same_signage
    : pred_base<(both_signed<T, F>::value) || (both_unsigned<T, F>::value)>
{
};

// And here, finally is the trait I wanted in the first place:  is_safe_numeric_cast

template <class T, class F>
struct is_safe_numeric_cast 
    : pred_base <both_numeric<T, F>::value &&                                                                         // Obviously both src and dest must be numbers
                 ( std::is_floating_point<T>::value && ( std::is_integral<F>::value || sizeof(T) >= sizeof(F) ) ) ||  // Floating dest: src must be integral or smaller/equal float-type
                 ( ( both_integral<T, F>::value ) &&                                                                  // Integral dest: src must be integral and (smaller/equal+same signage) or (smaller+different signage)
                   ( sizeof(T) > sizeof(F) || ( sizeof(T) == sizeof(F) && same_signage<T, F>::value ) ) )>
{
};