檢測整數截斷

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