Скобки, определяющие скобки и стек?

Question

Я только что прочитал этот вопрос: Why are different case condition bodies not in different scope?

Это вопрос Java, но мой вопрос касается как C#, так и Java (и любого другого языка с этой функцией уменьшения области).

В вопросе OP говорит о том, как он знает, что он может добавить вручную {}, чтобы уточнить объем каждого случая в коммутаторе. Мой вопрос: как это работает? Он поднимается вверх по стеку, как если бы это был вызов метода? Если да, то что он делает, чтобы он все еще имел доступ к другим переменным, объявленным перед этой областью?

Answer 1

Все, что он делает, это определение другой области действия, оно не переводится в вызов метода. Помните, что для местных жителей CLR/JVM может решить не использовать для них пространство стека, он может выбрать использование регистров процессора. В некоторых случаях, если вы извините каламбур, он может решить оптимизировать некоторых из местных жителей, поскольку они не нужны. Он может даже решить, что он может использовать один регистр или ячейку памяти «в стеке» для нескольких переменных, поскольку они никогда не будут перекрываться.

Принимая пример из связанного вопроса:

switch(condition) { 
    case CONDITION_ONE: { 
    int account = 27373; 
    } 
    case CONDITION_TWO: { 
    // account var not needed here 
    } 
    case CONDITION_THREE: { 
    // account var not needed here 
    } 
    case CONDITION_FOUR: { 
    int account = 90384; 
    } 
} 

Как можно заметить, что код функционально идентичен:

int account; 

switch(condition) { 
    case CONDITION_ONE: { 
    account = 27373; 
    } 
    case CONDITION_TWO: { 
    // account var not needed here 
    } 
    case CONDITION_THREE: { 
    // account var not needed here 
    } 
    case CONDITION_FOUR: { 
    account = 90384; 
    } 
} 

Поскольку переменная account никогда не используется в нескольких случаях, что означает это идеальный кандидат (в этом упрощенном примере) для использования регистра или одного пространства в памяти.

Answer 2

Сфера определяется компилятором во время компиляции. Это мало влияет на фактическое расположение памяти переменных. Поэтому, если бы я писал:

func() 
{ 
    int a; 
    { 
     int b; 
    } 
    { 
     int c; 
    } 
} 

Компилятор может выбрать, чтобы создать три переменные, и выделить место для всех трех в начале функции или он может просто выделить место для двух переменных, и использовать то же пространство для b & c.

Область применения - это просто то, что компилятор знает, когда переменная больше не нужна. Именно то, что он делает с этой информацией, - это бизнес.

Answer 3

Вопрос, как это работает? Он поднимается вверх по стеку, как если бы это был вызов метода?

Он работает так же, как любая другая пара {}, используемая для создания новой локальной области. Там нет никакой разницы scopewise между этим:

void foo() { 
    { 
     int a = 123; 
    } 
    // a is gone here 
    { 
     // different a 
     float a = 12.3f; 
    } 
} 

и это:

void foo() { 
    switch (123) { 
    case 1: 
     { 
      int a = 123; 
     } 
     // a is gone here 
     break; 

    case 2: 
     { 
      // different a 
      float a = 12.3f; 
     } 
    } 
} 

Если да, то что он делает так, что она по-прежнему имеет доступ к другим переменным, объявленным до этого объема?

Блоки всегда имеют доступ к их внешних областей или это не будет работать:

void foo() { 
    int a = 123; 
    if (true) { 
     a = 345; // accessing a in outer scope 
    } 
} 

Answer 4

Любые переменные, объявленные внутри рамки могут быть доступны только в пределах этого объема и любых областей внутри него. Таким образом, в функции вы можете использовать {} на многих языках программирования для создания переменных, которые будут разрушены при выходе из этой области.

Кроме того, могут возникнуть проблемы при использовании switch и не используют области, как показаны на этот небольшой кусок кода C:

int main() { 
    int foo = 4; 
    int bar = getbar(); // getbar() is a function returning an integer 
    switch(bar) 
    { 
    case 1: 
     int abc = 6; 
     break; 
    case 2: 
     int abc = 7; // compiler error: 'abc' was defined twice in this scope 
     break; 
    } 
} 
int abc = 147; // This is no error, as 'abc' fell out of scope when 
// leaving the `switch` statement 

Как вы можете видеть, abc дважды были объявлены в рамках switch , и это приводит к ошибке. Это было бы легко было исправлено, чтобы дать каждые case своих собственные переменные сферы:

int main() { 
    int foo = 4; 
    int bar = getbar(); // getbar() is a function returning an integer 
    switch(bar) 
    { 
    case 1: 
    { 
     int abc = 6; 
     break; 
    } 
    case 2: 
    { 
     int abc = 7; // no more errors, since these declarations will destruct when 
     // falling out of scope 
     break; 
    } 
    } 
} 
int abc = 147; // This is no error, as 'abc' fell out of scope when 
// leaving the `switch` statement