过早的优化还是我疯了？

Question

我最近在 comp.lang.c++ 上看到一段代码，它从函数返回静态整数的引用。代码是这样的

int& f()
{
   static int x;
   x++;
   return x;
}

int main()
{
  f()+=1; //A
  f()=f()+1; //B
  std::cout<<f();

}

当我使用我很酷的 Visual Studio 调试器调试应用程序时，我只看到了对语句 A 的一次调用，猜猜我震惊了什么。我一直认为 i+=1 等于 i=i+1 所以 f()+=1 将等于 f()=f()+1 并且我会看到对 f() 的两次调用>，但我只看到了一个。这到底是什么？我疯了还是我的调试器疯了或者这是过早优化的结果？

Answer 1

《标准》对 += 和朋友是这样说的：

5.17-7：E1 op= E2 形式的表达式的行为相当于
E1 = E1 op E2 除了 E1 是
仅评估一次。[...]

所以编译器在这一点上是正确的。

Answer 2

i+=1 功能与 i=i+1 相同。它实际上以不同的方式实现（基本上，它的设计是为了利用 CPU 级别的优化）。

但本质上左侧仅被评估一次。它产生一个非常量左值，这就是读取该值、加一并将其写回所需的全部内容。

当您为自定义类型创建重载运算符时，这一点更加明显。 operator+= 修改 this 实例。 operator+ 返回一个新实例。通常建议（在C++中）先写oop+=，然后根据它写op+。

（请注意，这仅适用于 C++；在 C# 中，op+= 与您的假设完全一样：只是 op+ 的简写形式，您无法创建自己的 op+=。它是从 Op+ 中自动为您创建的）

Answer 3

你的想法是合乎逻辑的，但不正确。

i += 1;
// This is logically equivalent to:
i = i + 1;

但逻辑上等价和相同并不相同。
代码应该看起来像这样：

int& x = f();
x += x;
// Now you can use logical equivalence.
int& x= f();
x = x + 1;

编译器不会进行两个函数调用，除非您显式地将两个函数调用放入代码中。如果你的函数有副作用（就像你所做的那样），并且编译器开始添加额外的难以看到的隐式调用，那么实际上很难理解代码的流程，从而使维护变得非常困难。

Answer 4

f() 返回对静态整数的引用。然后 += 1 向该内存位置加一 - 无需在语句 A 中调用它两次。

Answer 5

在我见过的每一种支持 += 运算符的语言中，编译器都会对左侧的操作数求值一次，以生成某种类型的地址，然后使用该地址读取旧值并写入新值。 += 运算符不仅仅是语法糖；它还是语法糖。正如您所注意到的，它可以实现表达语义，而通过其他方式很难实现这一点。

顺便说一下，vb.net 和 Pascal 中的“With”语句都有类似的功能。像这样的声明：

' Assime Foo is an array of some type of structure, Bar is a function, and Boz is a variable.
  With Foo(Bar(Boz))
    .Fnord = 9
    .Quack = 10
  End With

will compute the address of Foo(Bar(Boz)), and then set two fields of that structure to the values nine and ten. It would be equivalent in C to

  {
    FOOTYPE *tmp = Foo(Bar(Boz));
    tmp->Fnord = 9;
    tmp->Quack = 10;
  }

但 vb.net 和 Pascal 不公开临时指针。虽然在 VB.net 中无需使用“With”来保存 Bar() 的结果就可以实现相同的效果，但使用“With”可以避免使用临时变量。