检测整数截断

Question

可能重复：
Best way to detect integer overflow in C/C++

是什么，如果发生整数截断检测的最佳方式？
编辑
这应当引起截断而被发送信号，但它不会

#include <iostream> 

using std::cout; 
typedef signed int int32_t; 
typedef unsigned int uint32_t; 
typedef signed short int16_t; 
typedef unsigned short uint16_t; 


int32_t my32bitInt = 0xffffffff; 

int32_t tmp = my32bitInt & 0xFFFF8000; 

uint16_t ss = my32bitInt; 

int main() 
{ 

    if (tmp != 0xFFFF8000 && tmp != 0x00000000) 
    { // cannot be converted safely 
     cout << "truncation"; 
    } 
     cout << ss << '\n'; 
    cout << my32bitInt << '\n'; 
    return 0; 
} 

编辑2

template <typename U, typename T> 
bool is_safe(T t) 
{ 
    return sizeof(U) <= sizeof(T) ? 
    (t >= static_cast<T>(std::numeric_limits<U>::min())) 
     && (t <= static_cast<T>(std::numeric_limits<U>::max())) : true; 
}  

编辑3（基于奥利奇的<>） - 我发现了一些问题，但在它的工作，将尽快更新

模板 布尔is_safe（来源值） {

if (sizeof(Result) == sizeof(Source)) 
{/*Same size*/ 

    if (std::is_same<Source,Result>::value) 
    { 
     //signed to signed or unsigned to unsigned when size is same - no problem 
     return true; 
    } 
    else 
    { 
     //MSB mustn't be set in Source 
     return !(value & (1u << ((sizeof(Source) * CHAR_BIT) - 1))); 
    } 
} 
else 
{//smaller to larger and larger to smaller 

    if (sizeof(Result) <= sizeof(Source)) 
    { //Larger to smaller and both equal 
     return ((value >= static_cast<Source>(std::numeric_limits<Result>::min())) 
       && (value <= static_cast<Source>(std::numeric_limits<Result>::max()))); 
    } 
    else 
    { //smaller to larger 

     if (std::is_signed<Source>::value && !std::is_signed<Result>::value) 
     { 
      //signed to unsigned - signed must be positive 
      return (value >= 0); 
     } 
     else 
     { 
      return true; 
     } 
    } 
} 

}

Answer 1

您可以检查赋值后的值是否相同。

smallInt = largeInt; 

if (smallInt != largeInt) 
{ 
    // Truncation 
} 

或者，你可以前带口罩检查：

if (my32bitInt & 0xFFFF0000) 
{ 
    // Can't be assigned to a 16 bit value. 
} 

Answer 2

我不是一个C++程序员，但我认为你应该做这样的事情：

#include <iostream.h> 

int main() 
{ 

    float number = 0.001; 
    if ((int) number == number) 
    { 

     cout << "Hello world"; 
    } 
    return 0; 
} 

。希望是正确的解决方案。

Answer 3

如果你想检查没有做转换，在一个类型安全的方式，如何执行以下操作：

template <typename U, typename T> 
bool is_safe(T t) 
{ 
    return (t >= (T)std::numeric_limits<U>::min()) 
     && (t <= (T)std::numeric_limits<U>::max()); 
} 

int main() 
{ 
    int32_t a = -32768; 
    int32_t b = +32768; 
    int32_t c = +32767; 
    int32_t d = -32769; 
    std::cout << is_safe<int16_t>(a) << std::endl; // 1 
    std::cout << is_safe<int16_t>(b) << std::endl; // 0 
    std::cout << is_safe<int16_t>(c) << std::endl; // 1 
    std::cout << is_safe<int16_t>(d) << std::endl; // 0 
} 

很明显，如果U比T大一些，但是我相信它可以被修改。

Answer 4

参见Boost Numeric Conversion，特别是numeric_cast。

Answer 5

最安全的方法是在进行转换之前检查它。 These templates完全一样。例如：

/* unsigned -> signed, overflow */ 
safe_cast<short>(UINT_MAX); 

/* unsigned -> unsigned, overflow */ 
safe_cast<unsigned char>(ULONG_MAX); 

/* signed -> unsigned, overflow */ 
safe_cast<unsigned long>(-1); 

/* signed -> signed, overflow */ 
safe_cast<signed char>(INT_MAX); 

/* always works (no check done) */ 
safe_cast<long>(INT_MAX); 

// giving these assertion failures results 
(type)f <= (type)is_signed<To>::v_max 
f <= (To)-1 
f >= 0 
f >= is_signed<To>::v_min && f <= is_signed<To>::v_max