常见的做法如何处理整数溢出？

Question

从应用程序开发团队的角度来看，处理整数溢出如999999 * 999999（result> Integer.MAX_VALUE）的常见做法是什么？

可以让BigInt强制使用，禁止使用Integer，但这是一个好的/坏的想法？

Answer 1

如果该整数溢出非常重要的，你可以定义自己的溢出醒目的操作，例如：

def +?+(i: Int, j: Int) = { 
    val ans = i.toLong + j.toLong 
    if (ans < Int.MinValue || ans > Int.MaxValue) { 
    throw new ArithmeticException("Int out of bounds") 
    } 
    ans.toInt 
} 

您可以用充实，你的库模式把这个进入运营商;如果JVM管理做正确逃生的分析，你不会得到太多的罚款，因为它：

class SafePlusInt(i: Int) { 
    def +?+(j: Int) = { /* as before, except without i param */ } 
} 
implicit def int_can_be_safe(i: Int) = new SafePlusInt(i) 

例如：

scala> 1000000000 +?+ 1000000000 
res0: Int = 2000000000 

scala> 2000000000 +?+ 2000000000 
java.lang.ArithmeticException: Int out of bounds 
    at SafePlusInt.$plus$qmark$plus(<console>:12) 
    ... 

如果不是极其重要，那么标准的单元测试和代码评审等，这些应该会在大多数情况下发现问题。使用BigInt是可能的，但会使算术速度下降100倍左右，如果您必须使用采用Int的现有方法，则无法为您提供帮助。

Answer 2

到目前为止，最常见有关整数溢出的做法是，程序员应该知道，这个问题存在，以观察他们可能发生的情况，并进行相应的检查或者重新安排数学，使溢出赢得不会发生，像做*（b/c）而不是（a * b）/ c。如果项目使用单元测试，它们将包括尝试强制溢出的情况。

我从来没有从一个团队那里得到更多的代码，所以我要说对于几乎所有的软件都足够好了。

我见过的一个嵌入式应用程序实际上，诚实到意大利面怪兽需要防止溢出，他们通过证明溢出不可能在每一行中看起来像是可能发生的溢出。

Answer 3

如果你使用斯卡拉（基于我假设你是标签），一个非常通用的解决方案是写你的代码库对scala.math.Integral型类：

def naturals[A](implicit f: Integral[A]) = 
    Stream.iterate(f.one)(f.plus(_, f.one)) 

你也可以使用情境边界和Integral.Implicits为更好的语法：

import scala.math.Integral.Implicits._ 

def squares[A: Integral] = naturals.map(n => n * n) 

现在你可以使用这些方法要么Int或Long或BigInt根据需要，自实例为所有这些存在：

scala> squares[Int].take(10).toList 
res0: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100) 

scala> squares[Long].take(10).toList 
res0: List[Long] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100) 

scala> squares[BigInt].take(10).toList 
res1: List[BigInt] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100) 

无需更改库代码：只要使用Long或BigInt，其中溢出是一种关心和Int否则。

您将在表现方面付出一些代价，但通用性和推迟Int或BigInt决定的能力可能是值得的。

Answer 4

除了简单的正念之外，正如@mjfgates所指出的那样，在处理缩放十进制（非浮点）实数量时，我总是使用一些做法。这可能不适合您的特定应用程序 - 如果没有提前道歉。

首先，如果有多个度量单位在使用中，则值必须始终明确标识它们是什么。这可以通过命名约定，或者通过对每个度量单位使用单独的类。我一直使用名称 - 每个变量名都有一个后缀。除了消除errors from confusion over the units之外，它还鼓励对溢出的思考，因为这些措施不太可能被认为只是数字。其次，我最常见的溢出问题的来源通常是重新缩放 - 从一种度量转换为另一种度量 - 当它需要大量有效数字时。例如，从厘米到英寸的换算系数是0.393700787402。为了避免溢出和丢失有效数字，您需要小心按照正确的顺序进行乘法和除法。我没有在很长一段时间这样做，但我相信你想要的东西是一样的东西：

添加到Rational.scala，从书：

def rescale(i:Int) : Int = { 
     (i * (numer/denom)) + (i/denom * (numer % denom)) 

然后你得到的结果（从specs2缩短测试）：

val InchesToCm = new Rational(1000000000,393700787) 
    InchesToCm.rescale(393700787) must_== 1000000000 
    InchesToCm.rescale(1) must_== 2 

这不轮，或处理负比例因子。 生产实施可能需要分解出numer/denom和numer % denom。