标签: integer-overflow

如果我在C中执行以下代码:

#include <stdint.h>

uint16_t a = 4000;
uint16_t b = 8000;

int32_t c = a - b;

printf("%d", c);

它正确打印'-4000'作为结果.但是,我有点困惑:当从另一个中减去一个更大的无符号整数时,不应该有算术溢出吗？这里有什么施法规则？这个问题看起来有点愚蠢,所以任何参考文献都会非常感激.

为什么在C#中示例一个有效的,可编译的并且只是包装而示例B将无法编译？

一个

int val = 0;
val = val + Int32.MaxValue +2;

要么

int val = Int32.MaxValue;
val++;

乙

int val = 0;
val = 2147483647 + 1;

要么

int val = 0;
int val = Int32.MaxValue + 1;

默认情况下,我知道默认情况下不会检查算术异常,除非您使用配置中的checked方法,块或属性明确地这样做.我的问题更多地涉及编译器然后如何发生算术异常.

我希望签名整数在它们变得太大时溢出.如何在不使用下一个最大数据类型的情况下(或者当我已经在int128_t时)实现这一目标？

例如,使用8位整数19*12通常是260,但我希望结果1 11 10 01 00第9位被截止,因此-27.

这个快速排序应该将"v [left] ... v [right]排序为增加顺序"; K&R(第二版)从C编程语言中复制(不带注释):

void qsort(int v[], int left, int right)
{
    int i, last;
    void swap(int v[], int i, int j);

    if (left >= right)
        return;
    swap(v, left, (left + right) / 2);
    last = left;
    for (i = left+1; i <= right; i++)
        if (v[i] < v[left])
            swap(v, ++last, i);
    swap(v, left, last);
    qsort(v, left, last-1);
    qsort(v, last+1, right);
}

我觉得有一个错误

(left + right) / 2

假设left = INT_MAX - 1且right = INT_MAX.由于整数溢出,这不会导致未定义的行为吗？

背景:

鉴于以下n球:

'a' balls are of colour GREEN
'b' balls are of colour BLUE
'c' balls are of colour RED
...

(当然a + b + c + ... = n)

可以安排这些球的排列数量由下式给出:

perm = n! / (a! b! c! ..)

问题1:我怎样才能"优雅"计算perm,以避免整数溢出的尽可能长的时间,并确保当我做了计算,我要么有正确的值perm,或者我知道最后的结果会溢出？

基本上,我想避免使用像GNU GMP这样的东西.

可选地,问题2:这是一个非常糟糕的主意,我应该继续使用GMP吗？

在Java算术运算期间,JVM不会抛出下溢或溢出异常.很多时候,我们遇到了意想不到的结果,并想知道出了什么问题.

在.NET技术的情况下,我们有溢出和Undeflow异常.

所以我的问题是,为什么Java设计不会在算术运算期间抛出此异常

我知道(INT_MIN/-1)溢出,但(INT_MIN%-1)没有溢出.至少这是两个编译器中发生的事情,一个是前c ++ 11(VC++ 2010),另一个是后c ++ 11 GCC 4.8.1

int x = INT_MIN;
cout << x / -1 << endl; 
cout << x % -1 << endl;

得到:

-2147483648
0

此行为标准是定义的还是实现定义的？还有其他任何情况下除法操作会溢出吗？并且是否存在模数运算符溢出的情况？

在回答了这个问题之后,我很困惑为什么这个代码中的溢出整数导致了0而不是负数.这很奇怪,为什么这么准确？为何0？

public class IntegerOverflow {
  public static void main(String[] args) {
    int x = 10;

    int i = 0;
    for (i = 0; i <= 5; i++)
    {
      x = x * x;
      System.out.println(x);
    }
  }
}

输出:

100
10000
100000000
1874919424
0
0

在阅读这个问题的评论时,我遇到了一个指向comp.lang.c常见问题的链接,该链接显示了一个"小心添加功能",据称可以检测到整数溢出:

int
chkadd(int a, int b)
{
    if (INT_MAX - b < a) {
        fputs("int overflow\n", stderr);
        return INT_MAX;
    }
    return a + b;
}

如果这不会溢出怎么样b == -1？如果假设是a并且b都是积极的,为什么要制造它们int而不是unsigned int首先？

我需要将一种转换std::chrono::duration为另一种,但我需要知道何时无法进行这种转换,因为该值无法表示.

我没有在标准库中找到任何设施来检查这一点.该cppreference页面没有指定值是否超出范围会发生什么,只能从浮点到整数的转换可能是不确定的行为(在我来说,我需要从整数转换为整数).