标签: integer-overflow

令a、b 和c 为128 位数字。a * b当中间值溢出 128 位时，就会发生幻像溢出。然而，除法后的最终结果numerator / c可以容纳 128 位。

对于 64 位及更小的数字，可以转换为 128 位或使用muldiv crate。对于 128 位数字执行此操作的最佳方法是什么？问题是：

• Rust 没有大于 128 位的本机类型
• muldiv crate 不支持 128 位

参考资料-Remco Bloemen 的 muldiv in Solidity

我在 C# 中进行单元测试，发现以下代码给出了溢出异常：

using System;
                    
public class Program
{
    public static void Main()
    {
        int i = 0;
        Console.WriteLine(new float[i - 1]);
        // System.OverflowException: Arithmetic operation resulted in an overflow.
    }
}

https://dotnetfiddle.net/clbgZ3

但是，如果您显式尝试初始化负数组，则会收到以下错误：

Console.WriteLine(new float[-1]);
// Compilation error: Cannot create an array with a negative size

为什么初始化负大小的数组会导致溢出异常，而不是其他类型的错误？

我对int值的范围有疑问

int x=2147483647;     /*NO Error--this number is the maximum range 
                        of int value no error*/
int y=2147483648;     /*Error--one more than the
                        maximum range of int*/
int z=2147483647+1;  /*No Error even though it is one more
                       than the maximum range value*/

为什么？

可能重复:
在C/C++中检测整数溢出的最佳方法

我在接受采访时被问到这个问题:"将数字的字符串表示转换为整数".但是如果数字超过可以存储在32位整数中的最大值,则必须抛出错误.我的问题是我们如何检查数字是否溢出32位无符号整数？

我正在寻找一个Java库,可以处理真正庞大的数字或建议如何自己实现这个.我们正在谈论超越BigInteger.例如,2 ^ 39614081257132168796771974655 + 1怎么样.

显然,从理论上讲,我可以使用a TreeSet<BigInteger>,每位一个条目并完成所有数学老派,但我正在寻找能够使用内置数学硬件实际使用这些数字进行实际数学运算的东西.我不希望任何事情真的很快,但我非常想接近.

设置位的数量可能非常小 - 我代表G2多项式.

有谁知道那里有什么？

我怀疑包的功能必须是一个setBit(BigInteger i).

添加

感谢Apfloat的建议.可悲的是,以下是不可能的.它抱怨第二个参数必须是a long.

    Apint two = new Apint(2);
    Apint big = new Apint("39614081257132168796771974655");
    ApintMath.pow(two, big);

请注意,我也愿意接受有关如何自己完成此操作的建议.

添加 - 尝试重新打开.

请参阅user2246674的帖子,提醒我们这些数字是多么惊人 - 我可以向你保证,我们不是在谈论一些普通的数学图书馆,我们正在谈论一些严肃Math.pow(age-of-the-universe,atoms-in_the_galaxy)的数字 - 我们当然不是在寻找纯粹的自以为是的答案.

我想在Clojure中计算第500个Fibonacci数:

(defn fib-pair [[a b]] [b (+ a b)])
(nth (map first (iterate fib-pair [1 1])) 500)
ArithmeticException integer overflow  clojure.lang.Numbers.throwIntOverflow (Numbers.java:1388)

此程序失败,因为数字太大:整数溢出.如何解决这个问题呢？

我正在学习C++,做一些简单的例子,并发现了这种奇怪的行为.当填充整数数组的元素时,如果任何元素设置为大于2147483647(我认为是最大整数值？),则数组中的其余元素将设置为该确切数字,每个其中之一.

我理解如果一个元素超出其类型限制,编译器会将其限制为该限制,但我无法理解为什么它与其他项目做同样的事情,甚至没有要求用户填充它们.

这是我运行的一个简单测试:

#include <iostream>
using namespace std;

int main()
{
    int test[5];
    int num = 0;

    for (int i=0; i<5; i++)
    {
        cout << "Enter the number in position " << i << endl;
        cin >> num;
        test[i] = num;
    }

    cout << "Values in the array: " <<endl;
    for (int i=0; i<5; i++)
        cout << test[i] << endl;

}

感谢您阅读,评论和帮助!

试图在我的C++程序中添加异常处理,但我觉得它很混乱.程序将值i和j设置为它们的最高可能值并递增它们.我想我希望异常处理在发生时检测整数溢出/环绕(？)

到目前为止,这就是我所拥有的:

#include <iostream>
#include <limits.h>
#include <exception>
#include <stdexcept>
using namespace std;

int main() {
    int i;
    unsigned int j;

    try{
            i = INT_MAX;
            i++;
            cout<<i;
    }
    catch( const std::exception& e){
    cout<<"Exception Error!";
    }   


    try{
            j = UINT_MAX;
            j++;
            cout<<j;
    }
    catch(const std::exception& e){
    cout<<"Exception Error!";
    }
}

程序运行,但异常处理部分不起作用.

可能是什么问题？

我有一些针对某些财务应用程序的定点实现.它基本上是一个包含在类中的整数,它基于给定N的十进制数作为小数.该类是偏执的并检查溢出,但是当我在发布模式下运行我的测试时,它们都失败了,最后我创建了这个演示问题的最小例子:

#include <iostream>
#include <sstream>

template <typename T, typename U>
typename std::enable_if<std::is_convertible<U, std::string>::value, T>::type 
FromString(U&& str)
{
    std::stringstream ss;
    ss << str;
    T ret;
    ss >> ret;
    return ret;
}

int main()
{
    int NewAccu=32;
    int N=10;

    using T = int64_t;

    T l = 10;
    T r = FromString<T>("1" + std::string(NewAccu - N, '0'));
    if (l == 0 || r == 0) {
        return 0;
    }
    T res = l * r;
    std::cout << l << std::endl;
    std::cout …

我是Python的新手,我正在阅读这个页面,在那里我看到了一个奇怪的声明:

if n+1 == n:  # catch a value like 1e300
    raise OverflowError("n too large")

x等于大于它的数字？!我感觉到了原力的干扰.

我知道在Python 3中,整数没有固定的字节长度.因此,没有整数溢出,就像C的int工作方式一样.但当然内存无法存储无限数据.

我认为这就是为什么结果n+1可能是相同的n:Python不能分配更多的内存来预先形成总和,所以它被跳过,并且n == n是真的.那是对的吗？

如果是这样,这可能导致程序的错误结果.为什么Python不能在操作不可能时引发错误,就像C++一样std::bad_alloc？

即使n不是太大而且检查评估为假,result- 由于乘法 - 将需要更多的字节.可能result *= factor因同样的原因而失败？

我在官方Python文档中找到了它.这是检查大整数/可能整数"溢出"的正确方法吗？