这是 C++11 for 循环的已知缺陷吗？

Question

假设我们有一个结构，用于保存 3 个带有一些成员函数的双精度：

struct Vector {
  double x, y, z;
  // ...
  Vector &negate() {
    x = -x; y = -y; z = -z;
    return *this;
  }
  Vector &normalize() {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  // ...
};

为了简单起见，这有点做作，但我相信你同意类似的代码已经存在。这些方法允许您方便地链接，例如：

Vector v = ...;
v.normalize().negate();

甚至：

Vector v = Vector{1., 2., 3.}.normalize().negate();

现在，如果我们提供了 begin() 和 end() 函数，我们可以在新样式的 for 循环中使用我们的 Vector，比如循环 3 个坐标 x、y 和 z（毫无疑问，您可以构造更多"有用的”示例，通过将 Vector 替换为例如字符串）：

Vector v = ...;
for (double x : v) { ... }

我们甚至可以这样做：

Vector v = ...;
for (double x : v.normalize().negate()) { ... }

还有：

for (double x : Vector{1., 2., 3.}) { ... }

但是，以下（在我看来）被破坏了：

for (double x : Vector{1., 2., 3.}.normalize()) { ... }

虽然这似乎是前两种用法的逻辑组合，但我认为最后一种用法会创建一个悬空引用，而前两种完全没问题。

• 这是否正确并广受赞赏？
• 以上哪一部分是“坏”部分，应该避免？
• 是否可以通过更改基于范围的 for 循环的定义来改进语言，以便在 for 表达式中构造的临时对象在循环期间存在？

Answer 1

这是否正确并受到广泛赞赏？

是的，你对事物的理解是正确的。

以上哪一部分是“坏”的部分，应该避免？

不好的部分是对从函数返回的临时值进行左值引用，并将其绑定到右值引用。就像这样糟糕：

auto &&t = Vector{1., 2., 3.}.normalize();

无法延长临时 Vector{1., 2., 3.} 的生命周期，因为编译器不知道来自 normalize 的返回值引用了它。

是否可以通过更改基于范围的 for 循环的定义来改进语言，使得在 for 表达式中构造的临时对象在循环期间存在？

这与 C++ 的工作方式高度不一致。

它会防止人们在临时变量上使用链式表达式或对表达式使用各种惰性求值方法而造成某些问题吗？是的。但它也需要特殊情况的编译器代码，并且会混淆为什么它不能与 other 表达式构造一起使用。

更合理的解决方案是通知编译器函数的返回值始终是对this 的引用，因此如果返回值绑定到临时扩展构造，那么它将延长正确的临时。不过，这是一个语言级别的解决方案。

目前（如果编译器支持），您可以将其设置为临时调用 normalize ：

struct Vector {
  double x, y, z;
  // ...
  Vector &normalize() & {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  Vector &normalize() && = delete;
};

这将导致Vector{1., 2., 3.}.normalize() 产生编译错误，而v.normalize() 可以正常工作。显然，您将无法像这样做正确的事情：

Vector t = Vector{1., 2., 3.}.normalize();

但你也不能做错事。

或者，如 cmets 中所建议的，您可以使右值引用版本返回值而不是引用：

struct Vector {
  double x, y, z;
  // ...
  Vector &normalize() & {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  Vector normalize() && {
     Vector ret = *this;
     ret.normalize();
     return ret;
  }
};

如果Vector 是一个需要移动实际资源的类型，您可以改用Vector ret = std::move(*this);。命名的返回值优化使得这在性能方面达到了合理的最优。

Answer 2

for (double x : Vector{1., 2., 3.}.normalize()) { ... }

这不是语言的限制，而是您的代码的问题。表达式Vector{1., 2., 3.} 创建一个临时的，但normalize 函数返回一个lvalue-reference。因为表达式是一个左值，编译器假定对象是活着的，但是因为它是一个临时对象的引用，所以对象在完整的表达式被求值后就死了，所以你只剩下一个悬空参考。

现在，如果您更改设计以按值返回新对象，而不是对当前对象的引用，那么就没有问题，代码将按预期工作。

Answer 3

恕我直言，第二个例子已经有缺陷了。修改运算符返回 *this 以您提到的方式很方便：它允许链接修饰符。它可以用于简单地处理修改的结果，但是这样做很容易出错，因为它很容易被忽略。如果我看到类似的东西

Vector v{1., 2., 3.};
auto foo = somefunction1(v, 17);
auto bar = somefunction2(true, v, 2, foo);
auto baz = somefunction3(bar.quun(v), 93.2, v.qwarv(foo));

我不会自动怀疑这些函数会将v 修改为副作用。当然，他们可以，但这会令人困惑。所以如果我要写这样的东西，我会确保v 保持不变。对于您的示例，我将添加免费功能

auto normalized(Vector v) -> Vector {return v.normalize();}
auto negated(Vector v) -> Vector {return v.negate();}

然后编写循环

for( double x : negated(normalized(v)) ) { ... }

和

for( double x : normalized(Vector{1., 2., 3}) ) { ... }

IMO 可读性更好，也更安全。当然，它需要一个额外的副本，但是对于堆分配的数据，这很可能在廉价的 C++11 移动操作中完成。