这里有一个“不可移植”的解决方案。Intel x86和x64 cpu有所谓的eflags寄存器，在每次整数算术运算后由处理器填充。我将跳过这里的详细描述。相关的标志是“溢出”标志(掩码0x800)和“携带”标志(掩码0x1)。为了正确地解释它们，应该考虑操作数是有符号类型还是无符号类型。

下面是一个从C/ c++中检查标志的实用方法。下面的代码可以在Visual Studio 2005或更新版本(32位和64位)上运行，也可以在GNU C/ c++ 64位上运行。

#include <cstddef>
#if defined( _MSC_VER )
#include <intrin.h>
#endif

inline size_t query_intel_x86_eflags(const size_t query_bit_mask)
{
    #if defined( _MSC_VER )

        return __readeflags() & query_bit_mask;

    #elif defined( __GNUC__ )
        // This code will work only on 64-bit GNU-C machines.
        // Tested and does NOT work with Intel C++ 10.1!
        size_t eflags;
        __asm__ __volatile__(
            "pushfq \n\t"
            "pop %%rax\n\t"
            "movq %%rax, %0\n\t"
            :"=r"(eflags)
            :
            :"%rax"
            );
        return eflags & query_bit_mask;

    #else

        #pragma message("No inline assembly will work with this compiler!")
            return 0;
    #endif
}

int main(int argc, char **argv)
{
    int x = 1000000000;
    int y = 20000;
    int z = x * y;
    int f = query_intel_x86_eflags(0x801);
    printf("%X\n", f);
}

如果操作数相乘而没有溢出，则query_intel_eflags(0x801)将得到0的返回值，即既没有设置进位标志，也没有设置溢出标志。在提供的main()示例代码中，发生溢出，并且两个标志都被设置为1。这个检查并不意味着任何进一步的计算，所以它应该相当快。

这取决于你用它来做什么。 执行无符号长(DWORD)加法或乘法时，最佳解决方案是使用ULARGE_INTEGER。

ULARGE_INTEGER是一个由两个dword组成的结构。全部价值 可以访问为“QuadPart”，而高DWORD访问 作为“HighPart”，低DWORD作为“LowPart”访问。

例如:

DWORD
My Addition(DWORD Value_A, DWORD Value_B)
{
    ULARGE_INTEGER a, b;

    b.LowPart = Value_A;  // A 32 bit value(up to 32 bit)
    b.HighPart = 0;
    a.LowPart = Value_B;  // A 32 bit value(up to 32 bit)
    a.HighPart = 0;

    a.QuadPart += b.QuadPart;

    // If  a.HighPart
    // Then a.HighPart contains the overflow (carry)

    return (a.LowPart + a.HighPart)

    // Any overflow is stored in a.HighPart (up to 32 bits)

从C23开始，标准头文件<stdckdint.h>提供了以下三个类函数宏:

bool ckd_add(type1 *result, type2 a, type3 b);
bool ckd_sub(type1 *result, type2 a, type3 b);
bool ckd_mul(type1 *result, type2 a, type3 b);

其中type1, type2和type3是任何整数类型。这些函数分别以任意精度对a和b进行加、减或乘，并将结果存储在*result中。如果结果不能由type1精确表示，则函数返回true("计算已溢出")。(任意精确是一种错觉;计算速度非常快，自20世纪90年代初以来几乎所有可用的硬件都可以在一个或两个指令内完成。)

重写OP的例子:

unsigned long b, c, c_test;
// ...
if (ckd_mul(&c_test, c, b))
{
    // returned non-zero: there has been an overflow
}
else
{
    c = c_test; // returned 0: no overflow
}

C_test包含所有情况下可能溢出的乘法结果。

早在C23之前，GCC 5+和Clang 3.8+就提供了以同样方式工作的内置程序，除了结果指针是最后传递而不是第一个传递:__builtin_add_overflow， __builtin_sub_overflow和__builtin_mul_overflow。这些也适用于小于int的类型。

unsigned long b, c, c_test;
// ...
if (__builtin_mul_overflow(c, b, &c_test))
{
    // returned non-zero: there has been an overflow
}
else
{
    c = c_test; // returned 0: no overflow
}

Clang 3.4+引入了具有固定类型的算术溢出内置函数，但它们的灵活性要低得多，而且Clang 3.8现在已经可用很长时间了。如果你需要使用__builtin_umull_overflow，尽管有更方便的更新选项。

Visual Studio的cl.exe没有直接的等价物。对于无符号加减法，包括<intrin.h>将允许您使用addcarry_uNN和subborrow_uNN(其中NN是位数，如addcarry_u8或subborrow_u64)。他们的签名有点迟钝:

unsigned char _addcarry_u32(unsigned char c_in, unsigned int src1, unsigned int src2, unsigned int *sum);
unsigned char _subborrow_u32(unsigned char b_in, unsigned int src1, unsigned int src2, unsigned int *diff);

C_in /b_in是输入的进位/借位标志，返回值是输出的进位/借位。它似乎没有符号运算或乘法的等价物。

另外，Clang for Windows现在已经可以投入生产(对于Chrome来说已经足够好了)，所以这也是一个选择。

最简单的方法是将unsigned long转换为unsigned long，进行乘法运算，并将结果与0x100000000LL进行比较。

你可能会发现这比你在例子中做除法更有效。

哦，它在C和c++中都可以工作(因为你已经用这两种语言标记了问题)。

我在看glibc手册。这里提到了整数溢出陷阱(FPE_INTOVF_TRAP)作为SIGFPE的一部分。这将是理想的，除了手册中令人讨厌的部分:

FPE_INTOVF_TRAP 整数溢出(在C程序中不可能，除非您以特定于硬件的方式启用溢出捕获)。

真的有点遗憾。

salter先生的回答是个好主意。

如果整数计算是必需的(为了精度)，但浮点数是可用的，你可以这样做:

uint64_t foo(uint64_t a, uint64_t b) {
    double dc;

    dc = pow(a, b);

    if (dc < UINT_MAX) {
       return (powu64(a, b));
    }
    else {
      // Overflow
    }
}

内联程序集允许您直接检查溢出位。如果你打算使用c++，你真的应该学习汇编。