我用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++中检测有符号溢出。
当前回答
不能从C/ c++中访问溢出标志。
有些编译器允许你在代码中插入陷阱指令。在GCC上，选项是-ftrapv。
唯一可移植且与编译器无关的事情是自己检查溢出。就像你的例子一样。
但是，使用最新的GCC， -ftrapv似乎在x86上什么都不做。我猜这是一个旧版本的残余，或者特定于其他一些架构。我曾期望编译器在每次添加后插入一个INTO操作码。不幸的是，它不能这样做。
其他回答
CERT开发了一种新方法，使用“as-if”无限范围(AIR)整数模型来检测和报告有符号整数溢出、无符号整数包装和整数截断。CERT已经发布了一份描述该模型的技术报告，并生成了一个基于GCC 4.4.0和GCC 4.5.0的工作原型。
AIR整数模型产生的值与使用无限范围整数所获得的值相等，或者导致违反运行时约束。与之前的整数模型不同，AIR整数不需要精确的陷阱，因此不会破坏或抑制大多数现有的优化。
这里有一个非常快速的方法来检测溢出，至少是加法，这可能会为乘法、除法和乘方提供线索。
其思想是，正是因为处理器会让值归零，而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};
如果您有一个比您想要测试的数据类型大的数据类型(比如您做了一个32位的添加，而您有一个64位的类型)，那么这将检测是否发生溢出。我的例子是一个8位的添加。但它可以放大。
uint8_t x, y; /* Give these values */
const uint16_t data16 = x + y;
const bool carry = (data16 > 0xFF);
const bool overflow = ((~(x ^ y)) & (x ^ data16) & 0x80);
它基于本页解释的概念:http://www.cs.umd.edu/class/spring2003/cmsc311/Notes/Comb/overflow.html
对于一个32位的例子，0xFF变成0xFFFFFFFF, 0x80变成0x80000000，最后uint16_t变成uint64_t。
注意:这捕获整数加法/减法溢出，我意识到你的问题涉及乘法。在这种情况下，分裂可能是最好的办法。这通常是calloc实现确保参数在相乘以获得最终大小时不会溢出的一种方式。
内联程序集允许您直接检查溢出位。如果你打算使用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);
}
}
