找到两个值的平均值的正确方法是什么？

Question

我最近了解到整数溢出是 C 中未定义的行为（附带问题 - 它也是 C++ 中的 UB 吗？）

在 C 编程中，您通常需要找到 a 和 b 两个值的平均值。然而，(a+b)/2 可能会导致溢出和未定义的行为。

所以我的问题是 - 在 C 中找到两个值 a 和 b 的平均值的正确方法是什么？

Answer 1

在Secure Coding的帮助下

if (((si_b > 0) && (si_a > (INT_MAX - si_b))) ||
    ((si_b < 0) && (si_a < (INT_MIN - si_b))))
{
  /* will overflow, so use difference method */
  return si_b + (si_a - si_b) / 2;
} 
else
{
 /* the addition will not overflow */
  return (si_a + si_b) / 2;
}

附录

感谢@chux 指出舍入问题。这是一个经过正确舍入测试的版本...

int avgnoov (int si_a, int si_b)
{
    if ((si_b > 0) && (si_a > (INT_MAX - si_b)))
    {
      /* will overflow, so use difference method */
      /* both si_a and si_b > 0; 
          we want difference also > 0
          so rounding works correctly */
      if (si_a >= si_b)
        return si_b + (si_a - si_b) / 2;
      else
        return si_a + (si_b - si_a) / 2;
    } 
    else if ((si_b < 0) && (si_a < (INT_MIN - si_b)))
    {
      /* will overflow, so use difference method */
      /* both si_a and si_b < 0; 
          we want difference also < 0
          so rounding works correctly */
      if (si_a <= si_b)
        return si_b + (si_a - si_b) / 2;
      else
        return si_a + (si_b - si_a) / 2;
    }
    else
    {
     /* the addition will not overflow */
      return (si_a + si_b) / 2;
    }
}

Answer 2

(a >> 1) + (b >> 1) + (((a & 1) + (b & 1)) >> 1)

c int 数学中的移位语句 (x >> i) 相当于除以 2 的 i 次方。 所以语句 (a >> 1) + (b >> 1) 与 a/2 + b/2 相同。但是，还需要添加数字的截断部分的平均值。这个值可以通过掩码(a & 1)、加((a & 1) + (b & 1))和除(((a & 1) + (b & 1)) >> 1)得到。平均值变为 (a >> 1) + (b >> 1) + (((a & 1) + (b & 1)) >> 1)

注意：使用 >> 和 & 而不是 / 和 % 作为除法和余数运算符的原因之一是效率。

Answer 3

一个简单的方法如下

int c = a / 2 + ( b + a % 2 ) / 2;

例如a和b可以表示为

a = 2 * n + r1;
b = 2 * m + r2;

然后

( a + b ) / 2 => ( 2 * n + r1 + 2 * m + r2 ) / 2 => 2 * n / 2 + ( b + r1 ) / 2

最后一个表达式给你

=> a / 2 + ( b + a % 2 ) / 2

更正确的表述如下

int c = a / 2 + b / 2 + ( a % 2 + b % 2 ) / 2;

例如，如果我们有

int a = INT_MAX;
int b = INT_MAX;

然后c计算为

int c = a / 2 + b / 2 + ( a % 2 + b % 2 ) / 2;

会给c == INT_MAX

编辑：在计算机操作员的效果和数学操作员的效果之间发现了有趣的差异。 比如根据数学-1可以表示为

-1 = -1 * 2 + 1 

根据公式

a = 2 * n + r1

2 * n 应为小于或等于 tp a 的整数

所以小于-1的数字是-2。 :)

我认为我展示的一般公式会起作用，它要求对于奇数负数，将被视为小于奇数负数的偶数负数。

似乎正确的公式看起来像

int c = ( a < 0 ? a & ~1 : a ) / 2 + 
        ( b < 0 ? b & ~1 : b ) / 2 + 
        ( ( a & 1 ) + ( b & 1 ) ) / 2;

请务必注意，从数学角度来看，-1 和 -2 的平均值应等于 -2，并且公式给出了正确的结果。:)

Answer 4

如果您担心溢出，可以将值转换为更大的类型以执行数学运算，然后进行边界检查。

Answer 5

这是来自Calculating the average of two integer numbers rounded towards zero in a single instruction cycle：

(a >> 1) + (b >> 1) + (a & b & 0x1)

你必须考虑到：

• 它的实现定义了右移一个负整数是否将零或一移到高位。许多 CPU 通常有两种不同的指令：算术右移（保留符号位）和逻辑右移（不保留符号位）。允许编译器选择其中一个（大多数编译器选择算术移位指令）。

  ISO/IEC 9899:2011 §6.5.7 位移位运算符

  ¶5 E1 >> E2 的结果是 E1 右移 E2 位位置。 [CUT] 如果 E1 有带符号类型和负值，则结果值是实现定义的。

  将表达式更改为：

  a / 2 + b / 2 + (a & b & 0x1)
  

  不是解决方案，因为逻辑右移相当于除以 2 only for positive or unsigned numbers 的幂。

• (a & b & 0x1) 也没有很好的定义。当a 和b 都是奇数时，该项应该不为零。但它在补码表示和 ISO C 中失败，第 6.2.6.2/2 节指出an implementation can choose one of three different representations for integral data types：

  • 二进制补码
  • 补码
  • 符号/大小

  （通常两者的补码远远超过其他）。

Answer 6

在整个[INT_MIN...INT_MAX] 范围内平均两个int 的最简单（通常也是最快）方法是使用更宽的整数类型。 （由@user3100381 建议。）让我们称之为int2x。

int average_int(int a, int b) {
  return ((int2x) a + b)/2;
}

当然，这要求存在更宽的类型 - 所以让我们看看不需要更宽类型的解决方案。

挑战：

问：当int是奇数，而另一个是偶数时，应该以哪种方式取整？
A：按照上面的average_int() 向0 舍入。（截断）。

问：代码可以使用%吗？
A: 对于 C99 之前的代码，a % 2 的结果允许与a < 0 不同的结果。所以我们不要使用%。

问：int 是否需要正负数的大约对称范围？
答：自 C99 以来，负数的数量与正数的数量相同（或多 1 个）。让我们尽量不要这样。

解决方案：

执行测试以确定是否可能发生溢出。如果没有，只需使用(a + b) / 2。否则，将差值的一半（符号与答案相同）添加到较小的值。

下面给出了与average_int() 相同的答案，而无需求助于更广泛的整数类型。它 protects against int overflow 并且不需要 INT_MIN + INT_MAX 为 0 或 -1。它不依赖于编码为 2 的补码、1 的补码或符号大小。

int avgC2(int a, int b) {
  if (a >= 0) {
    if (b > (INT_MAX - a)) {
      // (a+b) > INT_MAX
      if (a >= b) {
        return (a - b) / 2 + b;
      } else {
        return (b - a) / 2 + a;
      }
    }
  } else {
    if (b < (INT_MIN - a)) {
      // (a+b) < INT_MIN
      if (a <= b) {
        return (a - b) / 2 + b;
      } else {
        return (b - a) / 2 + a;
      }
    }
  }
  return (a + b) / 2;
}

任何一对int最多出现3个if()s。

Answer 7

如果您只需要处理无符号整数类型（并且可以考虑二进制），您可以将您的加法分解为digit 和carry。我们可以将a+b（无限精度）写成(a^b) + ((a&b)<<1))，所以(a+b)/2 就是((a^b)>>1) + (a&b)。最后一个表达式适合a 和b 的常见类型，因此您可以在代码中使用它：

unsigned semisum(unsigned a, unsigned b)
{
    return ((a^b)>>1) + (a&b);
}

Answer 8

如果只有 2 个元素可以避免溢出，最简单的答案是：

(a/2) + (b/2) = average

对于更多元素，您可以使用：

(a/x) + (b/x) + (c/x) + (d/x) ..... = average //x = amount of elements

从数学角度，如果之前没有任何原始值发生过溢出，这将永远达到溢出，因为您不要真正将它们全部加在一起，而是先将它们分开，然后再将它们加在一起。因此，在计算期间执行的任何操作（包括结果）没有结果，将永远大于（到 0 的任一侧）大于最大的初始元素（假设您只使用Real Numbers）。

请执行以下操作：

1. 确定“C”中元素的数量，我们称之为total。
2. 声明一个值来存储平均值，我们称之为average。
3. 声明一个值来存储余数，我们称之为remainder。
4. 遍历它们并：
   • 将当前元素除以总量，total。
   • 将结果与平均值相加，average。
   • 将除法后的余数相加，remainder。
5. 将余数除以平均值，average。
6. 按平均水平做您需要/打算做的事情。

这将为您提供最多 1 的答案（十进制数字系统 [base 10]）。我还不懂C++，所以只能举个C#的例子。

C# 中的伪代码（仅供参考）：

int[] C = new int[20];            //The array of elements.
int total = C.Length;             //The total amount of elements.
int average = 0;                  //The variable to contain the result.
int remainder = 0;                //The variable to contain all the smaller bits.
foreach (int element in C)        //Iteration
{
    int temp = (element / total); //Divide the current element by the total.
    average = average + temp;     //Add the result to the average.
    temp = (temp % total);        //Get the remainder (number that was not divided)
    remainder = remainder + temp; //Add remainder to the other remainders.
}
average = average + (remainder / total); // Adds the divided remainders to the average.

压缩的 C# 示例：

int[] C = new int[20];               //The array of elements.
int total = C.Length;                //The total amount of elements.
int average = 0;                     //The variable to contain the result.
int remainder = 0;                   //The variable to contain all the smaller bits.
foreach (int element in C)           //Iteration
{
    average += (element / total);    //Add the current element divided by the total to the average.
    remainder += ( element % total); //Add the remainders together.
}
average += (remainder / total); //Adds the divided remainders to the total.