Использование {} в операторе case. Зачем?

Какой смысл в использовании {и }в caseзаявлении? Обычно, независимо от того, сколько строк в caseоператоре, выполняются все строки. Это просто правило относительно старых / новых компиляторов или за этим стоит что-то?

int a = 0;
switch (a) {
  case 0:{
    std::cout << "line1\n";
    std::cout << "line2\n";
    break;
  }
}

и

int a = 0;
switch (a) {
  case 0:
    std::cout << "line1\n";
    std::cout << "line2\n";
    break;
}

{}Обозначает новый блок сферы .

Рассмотрим следующий очень надуманный пример:

switch (a)
{
    case 42:
        int x = GetSomeValue();
        return a * x;
    case 1337:
        int x = GetSomeOtherValue(); //ERROR
        return a * x;
}

Вы получите ошибку компилятора, потому что xона уже определена в области видимости.

Разделение их на их собственные подсистемы устранит необходимость объявления xвне оператора switch.

switch (a)
{
    case 42: {
        int x = GetSomeValue();
        return a * x; 
    }
    case 1337: {
        int x = GetSomeOtherValue(); //OK
        return a * x; 
    }
}

TL; DR

Единственный способ объявить переменную с инициализатором или каким-либо нетривиальным объектом внутри кейса - это ввести область видимости блока, используя {}или другую структуру управления, которая имеет собственную область видимости, такую ​​как цикл или оператор if .

Кровавые подробности

Мы можем видеть, что кейсы - это просто помеченные операторы, такие как метки, используемые с оператором goto ( это описано в разделе 6.1 проекта стандарта C ++ с пометкой ), и мы можем видеть из 6.7параграфа 3 раздела, что переход объявления во многих случаях не допускается , в том числе с инициализацией:

Возможен переход в блок, но не в обход объявлений с инициализацией. Программа, которая перескакивает на ⁸⁷ из точки, где переменная с автоматической продолжительностью хранения не находится в области видимости, к точке, где она находится в области видимости, плохо сформирована, если только переменная не имеет скалярный тип, тип класса с тривиальным конструктором по умолчанию и тривиальным деструктором, квалифицированная cv версия одного из этих типов или массив одного из предыдущих типов и объявляется без инициализатора (8.5).

и предоставляет этот пример:

void f() {
 // ...
 goto lx; // ill-formed: jump into scope of a

 ly:
  X a = 1;
 // ...
 lx:
  goto ly; // OK, jump implies destructor
          // call for a followed by construction
          // again immediately following label ly
}

Обратите внимание, здесь есть некоторые тонкости, вы можете пропустить скалярное объявление , не имеющее инициализации, например:

switch( n ) 
{
    int x ;
    //int x  = 10 ; 
    case 0:
      x = 0 ;
      break;
    case 1:
      x = 1 ;
      break;
    default:
      x = 100 ;
      break ;
}

совершенно верно ( живой пример ). Конечно, если вы хотите объявить одну и ту же переменную в каждом случае, тогда каждому из них понадобится своя область видимости, но это работает так же, как и вне переключателя. операторов , так что это не должно быть большим сюрпризом.

Что касается обоснования запрета перехода после инициализации, отчет 467 о дефекте, хотя и охватывает несколько иную проблему, представляет собой разумный случай для автоматических переменных :

[...] автоматические переменные, если они не инициализированы явно, могут иметь неопределенные («мусорные») значения, включая представления ловушек, [...]

Вероятно, более интересно взглянуть на случай, когда вы расширяете область действия в рамках переключателя на несколько случаев, наиболее известным примером этого, вероятно, является устройство Даффа, которое будет выглядеть примерно так:

void send( int *to, const int *from, int  count)
{
        int n = (count + 7) / 8;
        switch(count % 8) 
        {
            case 0: do {    *to = *from++;   // <- Scope start
            case 7:         *to = *from++;
            case 6:         *to = *from++;
            case 5:         *to = *from++;
            case 4:         *to = *from++;
            case 3:         *to = *from++;
            case 2:         *to = *from++;
            case 1:         *to = *from++;
                        } while(--n > 0);    // <- Scope end
        }
}

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

Отметьте это базовым ограничением компилятора, и вы начнете задаваться вопросом, что происходит:

int c;
c=1;

switch(c)
{
    case 1:
    //{
        int *i = new int;
        *i =1;
        cout<<*i;
        break;
    //}

    default : cout<<"def";
}

Это даст вам ошибку:

error: jump to case label [-fpermissive]
error:   crosses initialization of ‘int* i’

Пока этого не будет:

int c;
c=1;

switch(c)
{
    case 1:
    {
        int *i = new int;
        *i =1;
        cout<<*i;
        break;
    }

    default : cout<<"def";
}

Использование скобок в переключателе обозначает новый блок области видимости, как сказал Ротем.

Но это также может быть для ясности при чтении. Чтобы знать, где остановится дело, поскольку в нем может быть условный разрыв.

Причины могут быть:

1. Удобочитаемость, он визуально увеличивает каждый случай как ограниченный раздел.
2. Объявление разных переменных с одинаковым именем для нескольких случаев переключения.
3. Микрооптимизации - область для очень дорогой переменной с выделенным ресурсом, которую вы хотите уничтожить, как только вы покинете область действия, или даже более спагетти-сценарий использования команды «GOTO».