为什么对“for”语句范围有特殊规则？

Question

我最近遇到了这个问题

for(int i=0,n=v.size(); i<n; i++) {
   ...
   P2d n = ...   <<<--- error here
}

编译器抱怨 n 局部变量已被定义，尽管左大括号看起来应该开始一个新的范围。

事实上，该标准对此有一个特殊的措辞，虽然使用 g++4.6.3 编译的代码很好，但它与更新的版本和其他编译器相冲突。

这个特殊规则背后的基本原理是什么（如果有的话）？

更清楚地说：标准说明这是不允许的，我对错误的技术原因没有任何疑问：我只是想知道为什么委员会决定使用特殊的额外规则，而不是在看到左大括号时创建另一个嵌套范围（就像在其他地方发生的那样）。

例如，为了使代码合法，您可以用 两个 大括号对而不是一个...

还请注意，for/while/if 之后的大括号虽然被认为是一种很好的做法，但 不是强制性的，也不是语法的一部分，但仍然存在包含循环变量的范围（因此使用函数定义作为另一个本地变量的范围是函数体的例子是不相关的：函数体不是语句，大括号是强制性的）。

在 C++ 语法中，for 的主体只是一个语句；但是，如果该语句恰好是一个花括号组，那么它会在 for/while/if 中得到特殊处理（当您在语言的其他地方使用花括号组作为语句时不会发生这种情况）。

在语言中添加这种额外的复杂性的原因是什么？显然不需要，只是将大括号视为另一个内部范围似乎（对我来说）更简单。

是否存在这种更简单、更常规的方法不起作用的用例？

请注意，我不是在征求意见。要么你知道委员会为什么做出这个决定（在标准中还需要一个非常详尽的措辞，而不是仅仅将正文作为常规语句，并在用作语句时定期处理大括号括起来的块），或者你不知道。

编辑

语法的“单一范围”视图对我来说是不自然的，但对于 for 语句在技术上是可行的，可以通过向后的 goto 语句将其合理化为单个块，但很难在非常相似的情况下进行辩护if 语句的情况：

if (int x = whatever()) {
    int x = 3; // Illegal
} else {
    int x = 4; // Illegal here too
}

但这是合法的

if (int x = whatever()) {
    int z = foo();
} else {
    int z = bar();
}

那么条件、then 部分和if 语句的else 部分是否相同范围？不，因为您可以声明两个 z 变量。它们是单独的范围吗？不，因为你不能声明x。

我能看到的唯一合理化是 then 和 else 部分确实是单独的范围，但是添加了（奇怪的）规则，即条件中声明的变量不能在范围中声明。为什么会出现这个奇怪的限制规则是我要问的。

Answer 1

int i = 0;
for (MyObject o1; i<10; i++) {
   MyObject o2;
}

可以从最近的编译器的角度翻译成：

int i = 0;
{
    MyObject o1;
    Label0:
    MyObject o2; //o2 will be destroyed and reconstructed 10 times, while being with the same scope as o1
    i++;
    if (i < 10)
        goto Label0;
}

这是你最后最后一个问号的答案，他们没有添加复杂的东西，只是在同一个范围内使用goto标记，而不是goto超出范围再进入。我看不出为什么它更好的明确原因。 （虽然它会与旧代码不兼容）

Answer 2

for 循环的语义并不特殊！ if (bool b = foo()) { } 的工作原理相同。奇怪的是，它本身就是一个{ } 块。如果不引入新的作用域，那将毫无用处。因此，明显的不一致是由于对例外情况的错误概括。

[编辑] 另一种观点是考虑一个假设的、可选的关键字：

// Not a _conditional_ statement theoretically, but grammatically identical
always()
{
    Foo();
}

这统一了规则，你也不会期望这里有三个范围（内部、中间、外部）。

[edit 2]（请不要将此作为回答的移动目标）

您想知道

中的生命周期和范围（两个不同的东西）

int i = 0;
for (MyObject o1; i<10; i++) {
   MyObject o2;
}

让我们概括一下：

MyObject o2; // Outer scope
int i = 0;
for (MyObject o1; i<o1.fooCount(); i++) {
   std::cout << o2.asString();
   MyObject o2;
}

显然，在所有迭代中，对o2.asString() 的调用指的是外部o2。这不像内部 o2 在循环迭代中幸存下来。当名称尚未在内部范围中定义时，名称查找不会使用外部范围中的名称 - 并且“尚未定义”是编译时的事情。内部o2的重复构造和销毁是运行时的事情。

Answer 3

这样看：
一对大括号允许您隐藏在封闭一对大括号（或全局）内可见的变量：

void foo(int n)
{
    // the containing block
    for (int i = 0; i < n; ++i)
    {
        int n = 5;  // allowed: n is visible inside the containing { }
        int i = 5;  // not allowed: i is NOT visible inside the containing { }
    }
}

如果你这样想，你会发现这里没有特殊的规则。

Answer 4

方括号 ({}) 将一段代码分隔为一个块。此块中的所有内容都在它自己的本地范围内：

int main(int argc, char** argv)
{
   int a  = 5;
   std::cout<<a<<std::endl      // 5
   {
       int a = 10;
       std::cout<<a<<std::endl  //10
   }
  std::cout<<a<<std::endl       // 5
}

但是等等，那段代码里还有别的东西……

int main(int argc, char** argv)
{
}

这类似于for循环的结构：

for (int i = 0 ; i < 5; i++)
{
}

函数定义在{...}块之外也有代码！
在这种情况下，argc 和 argv 被定义，并且它们在函数范围内是本地的，就像上面 for 循环中 i 的定义一样。

其实你可以将语法概括为：

definition { expression }

以上所有内容均在范围内。
在这种情况下，“原始”括号 ({}) 形成相同的结构，但定义语句为空。

编辑： 回答您的编辑，在：

int i = 0;
for (MyObject o1; i<10; i++) {
   MyObject o2;
}

o2 的构造函数在每个循环中循环，而 o1 的构造函数则没有。

for 循环行为如下（其中 XXX 是当前正在执行的块：

1. 初始化
   for(XXX; ; ){ }
2. 测试循环exp
   for( ;XXX; ){ }
3. 执行块
   for( ; ; ){XXX}
4. 最终操作
   for( ; ;XXX){ }
5. 回到 2。

Answer 5

由于 有 有c 标签，我将从这个角度回答。这是一个例子：

#include <stdio.h>

int main(void) {
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8};

    for (int i = 0, n = 8; i < n; i++) {
        int n = 100;
        printf("%d %d\n", n, a[i]);
    }

    return 0;
}

它编译没有问题，看到它在ideone（C99 严格模式，4.8.1）下工作。

C 标准明确将两个范围视为独立的，N1570 6.8.5/p5（强调我的）：

迭代语句是一个块，其范围是一个严格的子集 其封闭块的范围。循环体也是一个块，其 范围是迭代语句范围的严格子集。

有一个警告，但只有-Wshadow 选项，正如预期的那样：

$ gcc -std=c99 -pedantic -Wall -Wextra -Wshadow check.c
check.c: In function ‘main’:
check.c:7: warning: declaration of ‘n’ shadows a previous local
check.c:6: warning: shadowed declaration is here

Answer 6

循环控制变量（在本例中为i 和n）被视为for 循环 的一部分。 而且由于它们已经在循环的初始化语句中声明，大多数在循环中重新定义它们的尝试（除了使用嵌套大括号重新定义）都会导致错误！

Answer 7

我不能告诉你为什么for 循环只打开了一个范围，而不是因为大括号而打开了第二个范围。但我可以说当时给出的原因是改变单一范围的原因：局部性。采用这种非常标准的代码：

void foo(int n) {
  int s=0;
  for (int i=0; i<n; ++i) {
    s += global[i];
  }
  // ... more code ...
  for (int i=0; i<n; ++i) {
    global[i]--;
  }
}

根据旧规则，这将是非法代码，在同一范围内定义 i 两次，该函数。 （在当时的 C 中，它甚至是非法的，因为你必须在块的开头声明变量。）

这通常意味着你会在第二个循环中省略声明——如果第一个循环的代码被删除，就会遇到问题。不管你做了什么，你的变量都存在很长时间，这和往常一样让你的代码推理变得更加困难。 （那是在每个人和他们的兄弟开始认为十行长函数之前。）在此处的变量声明之前将for 更改为开始自己的作用域使代码更易于维护。

Answer 8

你的问题是for的定义部分被认为在for的范围内。

         // V one definition
for(int i=0,n=v.size(); i<n; i++) {
   ...
    // V second definition
   P2d n = ...   <<<--- error here
}