加倍数字 - 左移与乘法

Question

两者有什么区别

int size = (int)((length * 200L) / 100L); // (1)

和

int size = length << 1; // (2)

（两种情况下长度都是整数）

我假设两个代码 sn-ps 都希望将长度参数加倍。

我很想使用 (2) ... 那么使用 (1) 有什么好处吗？我查看了发生溢出时的边缘情况，两个版本似乎具有相同的行为。

请告诉我我错过了什么。

Answer 1

<< 比乘法更快的想法是在推理，好像 .NET jit 编译器实际上是 1970 年代编写的优化不佳的 C 编译器。即使这是真的，这个时间点的差异也会以皮秒为单位，即使存在差异，但可能没有。

编写代码，使其易于阅读。让编译器负责 pico 优化。根据分析现实场景优化您的代码，而不是再次猜测编译器将生成什么。

此外，移位运算符不与乘法具有相同的语义。例如，考虑以下编辑序列：

Jill 原创节目：

int x = y * 2;

鲍勃编辑：傻吉尔，我会让这个“更快”：

int x = y << 1;

实习生拉里编辑：哦，我们有一个错误，我们差了一个，让我来解决这个问题：

int x = y << 1 + 1;

Larry 刚刚引入了一个新错误。 y * 2 + 1 与 y

我在真实的生产代码中看到了这个错误。很容易在精神上陷入“移位就是乘法”的心态，而忘记了移位优先级低于加法，而乘法优先级高。

我从未见过有人通过写 x * 2 将算术优先级错误地乘以 2。人们理解 + 和 * 的优先级。很多人忘记了转移的优先级是什么。您实际上没有保存的皮秒是否值得任何数量的潜在错误？我拒绝。

Answer 2

这是第三个选项：

int size = length * 2; // Comment explaining what is 2 or what means this multiplication

这一定是最好的选择。因为它可读且易于理解您想要做什么。 至于性能，编译器正在生成相当优化的代码，因此无需担心如此简单的操作。 如果您对溢出有任何疑虑，可以使用checked 块。

编辑 正如许多其他人所提到的，只需在此处使用任何有意义的变量而不是 2。

Answer 3

对于普通程序员来说，哪个更易读：

int size = length * 2;
int size = length << 1;

除非他们来自强大的 C++ 位调整背景，否则我敢打赌你的普通程序员立即知道第一行是做什么的（它甚至有数字“2”代表“double”）但必须停下来停在第二行。

事实上，我倾向于评论第二行来解释它的作用，当你可以让代码像第一行那样说话时，这似乎是多余的。

Answer 4

有趣的是，大多数答案都认为编译器会将乘以 2 的幂优化为位移。很明显，没有一个响应者真正尝试过编译位移和乘法来查看编译器实际产生的结果。

这纯粹是一个学术练习；正如几乎每个人都指出的那样，乘法更容易阅读（尽管有人猜测为什么“* 200L / 100L”部分存在 - 这只是为了混淆事物）。同样很明显，在 C# 中用位移位替换乘法不会有任何显着的性能提升，即使在紧密循环中也是如此。如果您需要这种优化，那么您一开始就使用了错误的平台和语言。

让我们看看当我们使用 Visual Studio 2010 中包含的 CSC（C# 编译器）编译一个启用了优化的简单程序时会发生什么。这是第一个程序：

static void Main(string[] args)
{
    int j = 1;

    for (int i = 0; i < 100000; ++i)
    {
        j *= 2;
    }
}

使用 ildasm 反编译生成的可执行文件会为我们提供以下 CIL 清单：

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       23 (0x17)
  .maxstack  2
  .locals init ([0] int32 j,
           [1] int32 i)
  IL_0000:  ldc.i4.1
  IL_0001:  stloc.0
  IL_0002:  ldc.i4.0
  IL_0003:  stloc.1
  IL_0004:  br.s       IL_000e
  IL_0006:  ldloc.0
  IL_0007:  ldc.i4.2
  IL_0008:  mul
  IL_0009:  stloc.0
  IL_000a:  ldloc.1
  IL_000b:  ldc.i4.1
  IL_000c:  add
  IL_000d:  stloc.1
  IL_000e:  ldloc.1
  IL_000f:  ldc.i4     0x186a0
  IL_0014:  blt.s      IL_0006
  IL_0016:  ret
} // end of method Program::Main

这是第二个程序：

static void Main(string[] args)
{
    int j = 1;

    for (int i = 0; i < 100000; ++i)
    {
        j <<= 1;
    }
}

对它进行反编译会得到以下 CIL 清单：

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       23 (0x17)
  .maxstack  2
  .locals init ([0] int32 j,
           [1] int32 i)
  IL_0000:  ldc.i4.1
  IL_0001:  stloc.0
  IL_0002:  ldc.i4.0
  IL_0003:  stloc.1
  IL_0004:  br.s       IL_000e
  IL_0006:  ldloc.0
  IL_0007:  ldc.i4.2
  IL_0008:  shl
  IL_0009:  stloc.0
  IL_000a:  ldloc.1
  IL_000b:  ldc.i4.1
  IL_000c:  add
  IL_000d:  stloc.1
  IL_000e:  ldloc.1
  IL_000f:  ldc.i4     0x186a0
  IL_0014:  blt.s      IL_0006
  IL_0016:  ret
} // end of method Program::Main

注意第 8 行的区别。程序的第一个版本使用乘法 (mul)，而第二个版本使用左移 (shl)。

我不确定执行代码时 JIT 对它的作用，但 C# 编译器本身确实不将乘以 2 的幂优化为位移位。

Answer 5

200L 和 100L 代表什么？在我看来，您正在使用magic numbers。您应该尝试以尽可能好的方式描述其意图的方式编写您的程序；使其尽可能可读。对这些值使用命名常量而不是幻数是一种很好的方法。以自己命名的方法提取计算也有帮助。当您这样做时，您会立即看到无法将其重写为x << 1。不是因为结果会不同，而是因为可维护性会受到影响。当你编写像x << 1 这样的代码时，下一个程序员不知道这实际上意味着什么，它会增加著名的每分钟WTFs：

_{（来源：osnews.com）}

---

我认为您的代码应该看起来更像这样：

int size = CalculateSizeOfThing(length);

private static int CalculateSizeOfThing(int length)
{
    const long TotalArraySize = 200L;
    const long BytesPerElement = 100L;

    return (length * TotalArraySize) / BytesPerElement;
}

当然，这些 const 值的名称是一个疯狂的猜测 :-)

Answer 6

当我看到成语时：

int val = (someval * someConstant) / someOtherConstant;

我认为代码的意图是以某种方式进行缩放。它可能是手动定点代码，也可能是避免整数除法的问题。一个具体的例子：

int val = someVal * (4/5); // oops, val = 0 - probably not what was intended

或写为避免来回浮点数：

int val = (int)(someVal * .8); // better than 0 - maybe we wanted to round though - who knows?

当我看到这个成语时：

int val = someVal << someConstant;

我短暂地想知道 someVal 中的各个位是否有更深层次的含义需要移位，然后我开始查看周围的上下文以了解为什么要这样做。

要记住的是，当您编写具有以下内容的代码时：

int val = expr;

有无数种方法可以创建 expr 以使 val 始终具有相同的值。重要的是要考虑你在 expr 中对那些将要关注的人表达的意图。

Answer 7

这听起来像是过早的优化。只做 length * 2 的好处是编译器肯定会优化它并且更容易维护。

Answer 8

对于任何现代编译器，左移 1 或乘以 2 都会生成相同的代码。它可能是一个将数字添加到自身的添加指令，但这取决于您的目标。

另一方面，执行 (x*200)/100 与将数字加倍不同，因为第一次乘法可能会溢出，因此无法安全地优化以使数字加倍。

Answer 9

要回答您的实际问题，当length 是非负数int 并且代码文本位于unchecked 上下文中时，这两个代码片段之间似乎没有行为差异。

在checked 上下文中(int.MaxValue * 200L) 永远不会溢出，因为结果很容易适合long。 (int)((length * 200L) / 100L 只会在 length * 2 溢出时溢出。在任何情况下，移位运算符都不会溢出。因此，代码片段在 checked 上下文中的行为不同。

如果length 为负数，则移位运算将产生不正确的结果，而乘法将正常工作。因此，如果允许length 变量为负数，则两个代码片段是不同的。

（与流行观点相反，x 无符号 整数时它们才相同。）

Answer 10

无论代码可读性如何：位移位和整数乘法，即使是 2 的常数次方，通常也不相同。

没有编译器会“优化”x * 2 到 x << 1，除非它可以向自己证明 x 是一个非负整数。 （如果 x 的类型是unsigned int，那么根据定义当然是正确的。）它还需要知道溢出行为是相同的，或者不会发生溢出。 考虑以下 C# 示例：

int x = 2000000000, multiplied, shifted;
// Intention is to store results in 64-bit in case x is large:
long multA, shiftA, multB, shiftB;
checked
{
shifted = x << 1; // Overflows to negative number.
multiplied = x * 2; // Throws OverflowException.
shiftA = x << 1; // Maybe this overflows to negative number too?
multA = x * 2; // Maybe this throws OverflowException too?
shiftB = x << 1L; // Happens to double OK, because x is positive.
multB = x * 2L; // Works regardless of the value of x.
}

如果我在这里错了，请纠正我。