我用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++中检测有符号溢出。
当前回答
测试溢出的简单方法是通过检查当前值是否小于前一个值来进行验证。例如，假设你有一个循环输出2的幂:
long lng;
int n;
for (n = 0; n < 34; ++n)
{
lng = pow (2, n);
printf ("%li\n", lng);
}
添加溢出检查的方式，我描述的结果如下:
long signed lng, lng_prev = 0;
int n;
for (n = 0; n < 34; ++n)
{
lng = pow (2, n);
if (lng <= lng_prev)
{
printf ("Overflow: %i\n", n);
/* Do whatever you do in the event of overflow. */
}
printf ("%li\n", lng);
lng_prev = lng;
}
它既适用于无符号值，也适用于正负符号值。
当然，如果您想对递减值而不是递增值执行类似的操作，您可以将<=符号翻转，使其为>=，假设下溢的行为与溢出的行为相同。坦率地说，这是在不访问CPU溢出标志的情况下所获得的可移植性(这将需要内联汇编代码，使您的代码在实现之间无法移植)。
其他回答
一些编译器提供了对CPU中整数溢出标志的访问，然后可以测试，但这不是标准的。
您还可以在执行乘法之前测试溢出的可能性:
if ( b > ULONG_MAX / a ) // a * b would overflow
最简单的方法是将unsigned long转换为unsigned long，进行乘法运算，并将结果与0x100000000LL进行比较。
你可能会发现这比你在例子中做除法更有效。
哦，它在C和c++中都可以工作(因为你已经用这两种语言标记了问题)。
我在看glibc手册。这里提到了整数溢出陷阱(FPE_INTOVF_TRAP)作为SIGFPE的一部分。这将是理想的，除了手册中令人讨厌的部分:
FPE_INTOVF_TRAP 整数溢出(在C程序中不可能，除非您以特定于硬件的方式启用溢出捕获)。
真的有点遗憾。
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
int mltovf(int a, int b)
{
if (a && b) return abs(a) > MAX/abs(b);
else return 0;
}
main()
{
int a, b;
for (a = 0; a <= MAX; a++)
for (b = 0; b < MAX; b++) {
if (mltovf(a, b) != (a*b > MAX))
printf("Bad calculation: a: %d b: %d\n", a, b);
}
}
测试溢出的简单方法是通过检查当前值是否小于前一个值来进行验证。例如，假设你有一个循环输出2的幂:
long lng;
int n;
for (n = 0; n < 34; ++n)
{
lng = pow (2, n);
printf ("%li\n", lng);
}
添加溢出检查的方式，我描述的结果如下:
long signed lng, lng_prev = 0;
int n;
for (n = 0; n < 34; ++n)
{
lng = pow (2, n);
if (lng <= lng_prev)
{
printf ("Overflow: %i\n", n);
/* Do whatever you do in the event of overflow. */
}
printf ("%li\n", lng);
lng_prev = lng;
}
它既适用于无符号值，也适用于正负符号值。
当然，如果您想对递减值而不是递增值执行类似的操作，您可以将<=符号翻转，使其为>=，假设下溢的行为与溢出的行为相同。坦率地说，这是在不访问CPU溢出标志的情况下所获得的可移植性(这将需要内联汇编代码，使您的代码在实现之间无法移植)。
我看到你用的是无符号整数。根据定义，在C中(我不了解c++)，无符号算术不会溢出…所以，至少对C来说，你的观点是没有意义的:)
对于有符号整数，一旦出现溢出，就会发生未定义行为(UB)，程序可以做任何事情(例如:使测试不确定)。
#include <limits.h>
int a = <something>;
int x = <something>;
a += x; /* UB */
if (a < 0) { /* Unreliable test */
/* ... */
}
要创建一个符合要求的程序，您需要在生成溢出之前测试溢出。该方法也可以用于无符号整数:
// For addition
#include <limits.h>
int a = <something>;
int x = <something>;
if (x > 0 && a > INT_MAX - x) // `a + x` would overflow
if (x < 0 && a < INT_MIN - x) // `a + x` would underflow
// For subtraction
#include <limits.h>
int a = <something>;
int x = <something>;
if (x < 0 && a > INT_MAX + x) // `a - x` would overflow
if (x > 0 && a < INT_MIN + x) // `a - x` would underflow
// For multiplication
#include <limits.h>
int a = <something>;
int x = <something>;
// There may be a need to check for -1 for two's complement machines.
// If one number is -1 and another is INT_MIN, multiplying them we get abs(INT_MIN) which is 1 higher than INT_MAX
if (a == -1 && x == INT_MIN) // `a * x` can overflow
if (x == -1 && a == INT_MIN) // `a * x` (or `a / x`) can overflow
// general case
if (x != 0 && a > INT_MAX / x) // `a * x` would overflow
if (x != 0 && a < INT_MIN / x) // `a * x` would underflow
对于除法(INT_MIN和-1特殊情况除外)，不可能超过INT_MIN或INT_MAX。
