我怀疑RVO与移动构造，但我不是很确定。
是的，这几乎是肯定的，第一种情况是从函数的返回值移动初始化一个变量：在这种情况下，移动可以通过使函数初始化它来省略。第二种情况是从返回值中进行move-assign;赋值不能省略。我相信GCC即使在优化级别为零时也会执行省略，除非你显式地禁用它。
在最后一种情况下（-O3，现在已经从问题中删除），编译器可能注意到循环没有副作用，并将其完全删除。
通过声明向量volatile并使用优化进行编译，你可能会（也可能不会）得到一个更有用的基准测试，这将迫使编译器在每次迭代时实际创建/赋值它，即使它认为自己知道得更好。
初始化非POD数据时，循环中的自动声明是否被视为不良实践？
不;如果有的话，在所需的最窄范围内声明对象被认为是更好的实践。因此，如果只在循环中需要，就在循环中声明它。在某些情况下，在循环外声明一个复杂的对象以避免在每次迭代中重新创建它可能会获得更好的性能;但只有在您确信（a）存在性能优势并且（b）值得牺牲局部性时才这样做。

我看不出你的例子和auto有什么关系，你写了两个不同的程序。
当

for (size_t i = 0; i < 1000000; ++i)
    auto f = foo();

相当于

for (size_t i = 0; i < 1000000; ++i)
    std::vector<int> f = foo();

--这意味着，您创建一个新的向量（并销毁旧的向量）。是的，在您的foo-实现中使用RVO，但这不是这里的重点：您仍然在外部循环为f腾出空间的地方创建一个新的vector。
该片段

std::vector<int> f;
for (size_t i = 0; i < 1000000; ++i)
     f = foo();

使用assign到一个现有的向量。并且，是的，对于RVO，它可能变成一个move-assign，这取决于foo，在您的情况下，它是这样的，所以您可以期望它很快。但是它仍然是一个不同的东西-它总是f负责管理资源。
但你在这里非常漂亮地展示了遵循一般规则通常是有意义的
声明变量时应尽可能靠近它们的用途。
参见this Discussion

我在电脑上测试了3个版本。手动优化的版本是最快的。

constexpr size_t LOOP = 1000000000;

std::vector<int> foo() { return {1, 2, 3, 4, 5}; }

void foo_optimized(vector<int> &output) {
  constexpr static int values[] = {1, 2, 3, 4, 5};
  output.assign(&values[0], &values[0] + 5);
}

int main(int argc, char **argv) {
  string type = string(argv[1]);
  if (type == "original") {

    std::vector<int> f;
    for (size_t i = 0; i < LOOP; ++i)
      f = foo();

  } else if (type == "RVO") {

    for (size_t i = 0; i < LOOP; ++i)
      auto f = foo();

  } else if (type == "optimized") {

    std::vector<int> f;
    for (size_t i = 0; i < LOOP; ++i)
      foo_optimized(f);
  }

  return 0;
}

$ g++ a.cpp -O3
$ time ./a.out original && time ./a.out RVO && time ./a.out optimized

real    0m11.671s
user    0m11.662s
sys     0m0.000s

real    0m15.012s
user    0m15.011s
sys     0m0.000s

real    0m0.767s
user    0m0.759s
sys     0m0.000s

对于-O2，结果为：

• 原始版本-14.221s
• 遥控飞行器-14.993
• 优化- 4.483s