INT_MAX+a-b 是否不会导致溢出但 INT_MAX*a/b 会导致溢出（如果 a>1 且 a=b）？答案

【问题标题】：Is INT_MAX+a-b not cause overflow but INT_MAX*a/b cause overflow (if a>1 and a=b)?INT_MAX+a-b 是否不会导致溢出但 INT_MAX*a/b 会导致溢出（如果 a>1 且 a=b）？
【发布时间】：2015-06-11 03:11:43
【问题描述】：

我想解决一些关于溢出的问题。我有一些数据使用int来存储，数据不会导致溢出但计算中间可能会导致溢出。

比如我要存储正方形的对角线，边长是50000，所以对角线是70710，边和对角线都远小于INT_MAX，但是为了计算，aa+b sqrt(aa+bb) 中的 b 会导致溢出。

我想遵循“只使用 int”的规则，所以我可能每次都需要强制转换每个变量：

int f=(long)a+(long)b*(long)c/(long)d-(long)e;

但是每次add(long)都会影响可读性，我测试一下哪个操作可能会导致溢出，哪个可能有自动转换：

#include <sstream>
int main(){
    int a=rand();
    int b=a;
    printf("%d\n",a);
    printf("%d\n",INT_MAX);
    printf("\n");
    printf("%d\n",INT_MAX+a-b);
    printf("%d\n",INT_MAX-b+a);
    printf("%d\n",a+INT_MAX-b);
    printf("%d\n",a-b+INT_MAX);
    printf("%d\n",-b+a+INT_MAX);
    printf("%d\n",-b+INT_MAX+a);
    printf("\n");
    printf("%d\n",INT_MAX*a/b);
    printf("%d\n",INT_MAX/b*a);
    printf("%d\n",a*INT_MAX/b);
    printf("%d\n",a/b*INT_MAX);
    printf("\n");
    printf("%ld\n",(long)INT_MAX*a/b);
    printf("%ld\n",INT_MAX*a/(long)b);
    return 0;
}

输出是：

我使用 rand() 来确保没有编译时间计算，我发现 + 和 - 对于不同的 INT_MAX、+a 和 -b 序列的结果是相同的，但对于 *a 和 /b 则不是。

我还发现甚至使用强制转换，(long)INT_MAXa/b 是正常的，但 INT_MAXa/(long)b 不是。

我猜对于+和-，如果结果小于INT_MAX，即使计算中间（例如：INT_MAX+a-b中的INT_MAX+a）也不会导致溢出，但是对于*和/，溢出中间会影响结果，对吗？

同样对于*和/，我guest操作是从左侧开始的，所以铸造需要从左侧开始（例如：（long）INT_MAX*a/b），是不是也对？

所以，如果我的数据没有导致溢出但计算可能会导致溢出，是

int f=a+b*c/d-e;

只需要改写为

int f=a+(long)b*c/d-e;

【问题讨论】：

1.有符号整数溢出是未定义的行为。它可能看起来像是在某一时刻有效，但在一周内开始中断而没有任何变化。 2. long 可能与 int 大小相同，但仍会溢出（我知道 long 和 int 在 32 位 linux 以及 32 位和 64 位窗口上的大小相同）。
你只需要像int f = a + b*(long)c/d - e;这样的一次转换（仅供参考，适当地添加空格和换行符也有助于提高可读性），因为操作中的另一个操作数将相应地自动提升。你需要一个比int 更宽的类型，long 不能保证
INT_MAX+a 产生一个适合 int 的临时值，该值本身将被解释为负数。请参阅 ideone.com/mOiRS6 了解您的代码的略微修改版本。
@RSahu：不，INT_MAX+a 的评估产生了一个不适合结果类型 int 的值，这就是你得到未定义行为的原因。
@BenVoigt，理论上同意你的看法。但是，如果结果可以在特定运行时环境中多次运行复制，我会尝试理解为什么会发生这种情况。

标签： c++ integer-overflow

【解决方案1】：

数据不会溢出，但计算中间可能会溢出。

为避免int 溢出，即未定义行为，最简单的解决方案是使用足够宽的整数类型。

int foo1(int a, int b, int c, int d) {
  int f=(long)a+(long)b*(long)c/(long)d-(long)e; // OP's stating point, but see foo2
  return f;
}

但每次添加（长）都会影响可读性

为避免不必要的强制转换及其可读性，请仅在需要时使用* one。一个好的编译器会优化显式乘法，同时保留类型提升。

int foo2(int a, int b, int c, int d) {
  int f = a + 1L*b*c/d - e; // Cleaner yet see foo3
  return f;
}

为确保潜在的更宽类型足够宽（long 可能与 int 宽度相同），请执行编译时测试

// Find a type where INT_MAX*INT_MAX <= some_type_MAX
#if LONG_MAX/INT_MAX >= INT_MAX
  #define WIDE1 1L
#elif LLONG_MAX/INT_MAX >= INT_MAX
  #define WIDE1 1LL
#elif INTMAX_MAX/INT_MAX >= INT_MAX
  #define WIDE1 ((intmax_t)1)
#else
  #error Out of luck
#endif

int foo3(int a, int b, int c, int d) {
  int f = a + WIDE1*b*c/d - e;
  return f;
}

只使用类型 int 数学是工作要避免的。

..但是为了计算，sqrt(aa+bb)中的aa+bb会导致溢出。

对于这种情况

int hypoti1(int a, int b) {
  return sqrt(WIDE1*a*a + WIDE1*b*b);
}

// or simply

int hypoti1(int a, int b) {
  return hypot(a, b);
}

【讨论】：

这段代码可读性不强，我不会让它通过代码审查。
@ZalmanStern 很高兴您在 DV 中发表了评论。请提供更多细节或替代方案，以便改进答案。
我的反对意见是乘法技术掩盖了类型扩展。在花费大量时间对成像管道进行逆向工程之后，我更喜欢代码明确其精度要求。使用演员表可以使意图更加清晰，并且只需要一个。在 C++ 中，可以使用类型特征技术来推断要使用的类型，但在实践中，使用显式大小的整数类型并在其处理的位大小中使代码具体化可能会更好。除此之外，还有一些技术可以确保不会由于中间操作而发生溢出，这就是 hypot 所做的。
@ZalmanStern "使用强制转换使意图更清晰" (some_type)a*a 确实确保乘法发生时至少具有 (some_type) 和 a 类型的宽度。然而，铸造有可能缩小a - 因此我希望避免它。 WIDE1*a*a 无论如何都不会缩小乘法范围。将type*type 与2x wide type 相乘最好使用辅助函数而不是强制转换或WIDE1* 的想法。