Зачем нужны специальные правила для области заявления `for`?

Ответ 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 для маркировки в той же области видимости и не переходили в область действия, а затем снова вводили его. Я не вижу ясной причины, почему это лучше. (Хотя он будет несовместим со старыми кодами)

Ответ 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 - это время выполнения.

Ответ 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 { }
    }
}

Если вы думаете об этом таким образом, вы понимаете, что здесь нет особых правил.

Ответ 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, и они являются локальными для области действия, точно так же, как определение i в приведенном выше цикле for.

Фактически вы можете обобщить синтаксис на:

definition { expression }

Если все вышеперечисленное находится в пределах области действия.
В этом случае "необработанные" скобки ({}) образуют одну и ту же структуру, но с пустой инструкцией определения.

изменить: для ответа на ваше редактирование, в:

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

конструктор для o2 зацикливается для каждого цикла, а конструктор для o1 не является.

for поведение цикла происходит следующим образом (где XXX - текущий исполняемый блок:

• INIT
  for(XXX; ; ){ }
• test loop exp
  for( ;XXX; ){ }
• выполнить блок
  for( ; ; ){XXX}
• окончательная операция
  for( ; ;XXX){ }
• Вернуться к 2.

Ответ 5

Переменные управления циклом (i и n в этом случае) считаются частью цикла for. И поскольку они уже объявлены в заявлении инициализации цикла, большинство попыток (кроме переопределения с помощью вложенных фигурных скобок) для переопределения их в цикле приводит к ошибке!

Ответ 6

Как есть, был 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 (акцент мой):

Оператор итерации представляет собой блок, объем которого является строгим подмножеством объем его вмещающего блока. Тело цикла также является блоком, scope - это строчное подмножество области действия итерации.

Существует предупреждение, но только с опцией -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

Ответ 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 дважды в той же области действия. (В то время он был даже незаконным, потому что вам нужно было объявить переменные в начале блока.)

Это обычно означало, что вы оставите объявление во втором цикле и столкнетесь с проблемами, если код с первым циклом был удален. И что бы вы ни делали, у вас были переменные с долгой жизнью, которые, как обычно, усложняют рассуждение о вашем коде. (Это было прежде, чем каждый и их брат начали рассматривать десять строк как долгое функционирование.) Меняя for, чтобы начать свою собственную область, прежде чем объявление переменной здесь сделает код намного проще в обслуживании.

Ответ 8

Проблема заключается в том, что часть определения for рассматривается внутри области for.

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