我用c++写了一个程序来寻找ab = C的所有解，其中a, b和C一起使用所有的数字0-9，只使用一次。程序循环遍历a和b的值，并每次对a、b和ab运行数字计数例程，以检查是否满足数字条件。
但是，当ab超出整数限制时，会产生伪解。我最终使用如下代码来检查这个:
unsigned long b, c, c_test;
...
c_test=c*b; // Possible overflow
if (c_test/b != c) {/* There has been an overflow*/}
else c=c_test; // No overflow
是否有更好的方法来测试溢出?我知道有些芯片有一个内部标志，在溢出发生时设置，但我从未见过通过C或c++访问它。
注意，有符号int溢出在C和c++中是未定义的行为，因此您必须在不实际引起它的情况下检测它。对于加法前的有符号整型溢出，请参见在C/ c++中检测有符号溢出。
当前回答
Clang现在支持有符号整数和无符号整数的动态溢出检查。参见-fsanitize=integer开关。目前，它是唯一完全支持用于调试目的的动态溢出检查的c++编译器。
其他回答
Clang现在支持有符号整数和无符号整数的动态溢出检查。参见-fsanitize=integer开关。目前，它是唯一完全支持用于调试目的的动态溢出检查的c++编译器。
这里有一个非常快速的方法来检测溢出，至少是加法，这可能会为乘法、除法和乘方提供线索。
其思想是，正是因为处理器会让值归零，而C/ c++是从任何特定的处理器抽象出来的，你可以:
uint32_t x, y;
uint32_t value = x + y;
bool overflow = value < (x | y);
这既确保了如果一个操作数为零，另一个操作数为零，则不会错误地检测到溢出，而且比前面建议的许多NOT/XOR/ and /test操作要快得多。
正如所指出的，这种方法虽然比其他更精细的方法更好，但仍然是可优化的。以下是包含优化的原始代码的修订:
uint32_t x, y;
uint32_t value = x + y;
const bool overflow = value < x; // Alternatively "value < y" should also work
一种更有效、更廉价的检测乘法溢出的方法是:
uint32_t x, y;
const uint32_t a = (x >> 16U) * (y & 0xFFFFU);
const uint32_t b = (x & 0xFFFFU) * (y >> 16U);
const bool overflow = ((x >> 16U) * (y >> 16U)) +
(a >> 16U) + (b >> 16U);
uint32_t value = overflow ? UINT32_MAX : x * y;
这将导致UINT32_MAX溢出，或乘法的结果。在这种情况下，允许对有符号整数进行乘法运算是严格未定义的行为。
值得注意的是，这使用部分Karatsuba方法乘法分解来计算64位乘法的高32位，以检查是否应该设置它们中的任何一个，以了解32位乘法是否溢出。
如果使用c++，你可以把这个转换成一个简洁的小lambda来计算溢出，这样检测器的内部工作就被隐藏了:
uint32_t x, y;
const bool overflow
{
[](const uint32_t x, const uint32_t y) noexcept -> bool
{
const uint32_t a{(x >> 16U) * uint16_t(y)};
const uint32_t b{uint16_t(x) * (y >> 16U)};
return ((x >> 16U) * (y >> 16U)) + (a >> 16U) + (b >> 16U);
}(x, y)
};
uint32_t value{overflow ? UINT32_MAX : x * y};
要以一种可移植的方式执行无符号乘法而不溢出，可以使用以下方法:
... /* begin multiplication */
unsigned multiplicand, multiplier, product, productHalf;
int zeroesMultiplicand, zeroesMultiplier;
zeroesMultiplicand = number_of_leading_zeroes( multiplicand );
zeroesMultiplier = number_of_leading_zeroes( multiplier );
if( zeroesMultiplicand + zeroesMultiplier <= 30 ) goto overflow;
productHalf = multiplicand * ( c >> 1 );
if( (int)productHalf < 0 ) goto overflow;
product = productHalf * 2;
if( multiplier & 1 ){
product += multiplicand;
if( product < multiplicand ) goto overflow;
}
..../* continue code here where "product" is the correct product */
....
overflow: /* put overflow handling code here */
int number_of_leading_zeroes( unsigned value ){
int ctZeroes;
if( value == 0 ) return 32;
ctZeroes = 1;
if( ( value >> 16 ) == 0 ){ ctZeroes += 16; value = value << 16; }
if( ( value >> 24 ) == 0 ){ ctZeroes += 8; value = value << 8; }
if( ( value >> 28 ) == 0 ){ ctZeroes += 4; value = value << 4; }
if( ( value >> 30 ) == 0 ){ ctZeroes += 2; value = value << 2; }
ctZeroes -= x >> 31;
return ctZeroes;
}
对于无符号整数，只需检查结果是否小于其中一个参数:
unsigned int r, a, b;
r = a + b;
if (r < a)
{
// Overflow
}
对于有符号整数，可以检查参数和结果的符号。
不同符号的整数不能溢出，相同符号的整数只有在结果为不同符号时才会溢出:
signed int r, a, b, s;
r = a + b;
s = a>=0;
if (s == (b>=0) && s != (r>=0))
{
// Overflow
}
x86指令集包括一个无符号乘法指令，它将结果存储到两个寄存器中。要使用C中的指令，可以在64位程序(GCC)中编写以下代码:
unsigned long checked_imul(unsigned long a, unsigned long b) {
unsigned __int128 res = (unsigned __int128)a * b;
if ((unsigned long)(res >> 64))
printf("overflow in integer multiply");
return (unsigned long)res;
}
对于32位程序，需要使结果为64位，参数为32位。
另一种方法是使用依赖于编译器的intrinsic来检查标志寄存器。关于溢出的GCC文档可以从6.56内置函数执行溢出检查算术中找到。
