累积和溢出

Question

假设我要加 1+11+111....加 n 次。 很明显，从n的某个值来看，可能存在累积和的溢出。

假设我使用以下非常简单的函数来计算上面的总和：

int calcSum(int num)
{
    int sum = 0, sequnt = 1, i;

    for (i = 0; i < num; i++)
    {
        sum += sequnt;
        sequnt = (sequnt * 10) + 1;
    }

    return sum;
}

我想为该函数添加溢出检查。

我试图在这里获得一些帮助How to check if a number overflows an 'int'

但我不得不承认它让我感到困惑，而且我仍然发现在我的任务中实现它有些困难。

任何帮助都将不胜感激。

Answer 1

由于 2 个加法或乘法中的任何一个都大致是溢出候选者，因此请为每个调用一个安全的 overflow checker。使用<limits.h> 中的常量来指导范围检查。

#include <limits.h>
int is_undefined_add(int a, int b) {
  return (a < 0) ? (b < INT_MIN - a) : (b > INT_MAX - a);
}

int is_undefined_mult(int a, int b) {
  if (a > 0) {
    if (b > 0) {
      return a > INT_MAX / b;       // a positive, b positive
    }
    return b < INT_MIN / a;         // a positive, b not positive
  }
  if (b > 0) {
    return a < INT_MIN / b;         // a not positive, b positive
  }
  return a != 0 && b < INT_MAX / a; // a not positive, b not positive
}

int calcSum(int num) {
  int sum = 0, sequnt = 1, i;

  for (i = 0; i < num; i++) {
    if (is_undefined_add(sum, sequnt) Handle_Overflow();
    sum += sequnt;

    if (is_undefined_mult(sequnt, 10) Handle_Overflow();
    sequnt *= 10;

    if (is_undefined_add(sequnt, 1) Handle_Overflow();
    sequnt++;
  }

  return sum;
}

---

is_undefined_add() 和is_undefined_mult() 对int a, int b 的所有组合都有效。

Answer 2

只需使用来自limits.h 的INT_MAX

int calcSum(int num)
{
    int sum = 0, sequnt = 1, i;

    for (i = 0; i < num; i++)
    {
        if (INT_MAX - sequnt < sum) exit(1); // overflow
        sum += sequnt;
        if (INT_MAX/10 <= sequnt) exit(1); // overflow on the two next sentences.
        sequnt *= 10;
        sequnt++;
    }

    return sum;
}

exit(1) 只是为了使示例简短。您可以添加任何您喜欢的错误处理。

Answer 3

如果您确定您使用的是二进制补码有符号整数，那么您可以检查以下内容：两个正数相加必须给出正结果，两个负数相加必须给出负结果。只有一个总和不可能得到两个溢出，所以如果你添加正数，当你的结果第一次为负时就会出现溢出。

无论哪种情况，如果您希望您的代码可移植，那么建议您执行类似的操作：

#include <limits.h>
...
    if ((a > 0 && b > 0 && MAX_INT - a > b) ||
        (a < 0 && b < 0 && MIN_INT - a < b)) {
        /* OVERFLOW OF a + b WILL OCCUR */
        ...
    }

如果操作数的符号不同，则a + b的绝对值不可能大于a或b，因此不可能发生溢出。

对于unsigneds，你有一个类似的方法（虽然你保存了一半的测试，因为操作数只能是正数）但是这次第一种方法总是有效的（因为标准说无符号加法被认为是一个求和模块@ 987654326@ 其中n 是以位为单位的字长），在这种情况下，您可以求和，然后检查结果是否小于任何操作数（如果两者都是正数，则总和必须大于或等于任何一个操作数）：

unsigned a, b;

...
unsigned sum = a + b;
if (sum < a || sum < b) {
    /* OVERFLOW ON a + b HAS HAPPENED */
    ...
}

您还必须检查整数乘法溢出。如果a 和b 相乘，那么a*b 会溢出。但是这一次问题更进一步，因为溢出可能不止一次发生，而且你不能后验。在这种情况下，您可以使用等号或不同号溢出，因为您正在添加 a 次 b（并且 b 与自身具有相同的符号）如果两个符号相等，则乘积将为正，并且溢出将发生

if (MAX_INT/b < a) { /* overflow */ }

如果符号不同，乘积应该是负数，然后

if (MIN_INT/b < a) { /* overflow */ }

如果其中一个数为0，则乘法不会溢出，结果为0。