Por que variáveis ​​não podem ser declaradas em uma instrução switch?

Eu sempre me perguntei isso - por que você não pode declarar variáveis ​​após um rótulo de caso em uma instrução switch? Em C ++, você pode declarar variáveis ​​praticamente em qualquer lugar (e declará-las próximas ao primeiro uso é obviamente uma coisa boa), mas o seguinte ainda não funcionará:

switch (val)  
{  
case VAL:  
  // This won't work
  int newVal = 42;  
  break;
case ANOTHER_VAL:  
  ...
  break;
}  

O texto acima fornece o seguinte erro (MSC):

a inicialização de 'newVal' é ignorada pelo rótulo 'case'

Isso também parece ser uma limitação em outros idiomas. Por que isso é um problema?

Casedeclarações são apenas rótulos . Isso significa que o compilador interpretará isso como um salto diretamente para o rótulo. Em C ++, o problema aqui é de escopo. Seus colchetes definem o escopo como tudo dentro da switchinstrução. Isso significa que você terá um escopo no qual um salto será executado ainda mais no código, ignorando a inicialização.

A maneira correta de lidar com isso é definir um escopo específico para essa caseinstrução e definir sua variável nela:

switch (val)
{   
case VAL:  
{
  // This will work
  int newVal = 42;  
  break;
}
case ANOTHER_VAL:  
...
break;
}

Esta questão é originalmente foi etiquetado como [C] e [C ++], ao mesmo tempo. O código original é realmente inválido em C e C ++, mas por razões não relacionadas completamente diferentes.

• No C ++, esse código é inválido porque o case ANOTHER_VAL:rótulo salta para o escopo da variável newValignorando sua inicialização. Saltos que ignoram a inicialização de objetos automáticos são ilegais no C ++. Este lado do problema é abordado corretamente pela maioria das respostas.

• No entanto, na linguagem C, ignorar a inicialização de variáveis ​​não é um erro. Saltar para o escopo de uma variável sobre sua inicialização é legal em C. Isso significa simplesmente que a variável é deixada não inicializada. O código original não é compilado em C por um motivo completamente diferente. A etiqueta case VAL:no código original é anexada à declaração da variável newVal. Na linguagem C, as declarações não são declarações. Eles não podem ser rotulados. E é isso que causa o erro quando esse código é interpretado como código C.

  switch (val)  
  {  
  case VAL:             /* <- C error is here */
    int newVal = 42;  
    break;
  case ANOTHER_VAL:     /* <- C++ error is here */
    ...
    break;
  }

A adição de um {}bloco extra corrige os problemas de C ++ e C, mesmo que esses problemas sejam muito diferentes. No lado do C ++, ele restringe o escopo de newVal, certificando-se de que case ANOTHER_VAL:não entra mais nesse escopo, o que elimina o problema do C ++. No lado C, extra {}introduz uma declaração composta, fazendo com que o case VAL:rótulo se aplique a uma declaração, o que elimina a emissão de C.

• No caso C, o problema pode ser facilmente resolvido sem o {}. Basta adicionar uma declaração vazia após o case VAL:rótulo e o código se tornará válido

  switch (val)  
  {  
  case VAL:;            /* Now it works in C! */
    int newVal = 42;  
    break;
  case ANOTHER_VAL:  
    ...
    break;
  }

  Observe que, embora agora seja válido do ponto de vista de C, ele permanece inválido do ponto de vista de C ++.

• Simetricamente, no caso de C ++, o problema pode ser facilmente resolvido sem o {}. Apenas remova o inicializador da declaração da variável e o código se tornará válido

  switch (val)  
  {  
  case VAL: 
    int newVal;
    newVal = 42;  
    break;
  case ANOTHER_VAL:     /* Now it works in C++! */
    ...
    break;
  }

  Observe que, embora agora seja válido do ponto de vista do C ++, ele permanece inválido do ponto de vista do C.

Está bem. Só para esclarecer isso, nada tem a ver com a declaração. Diz respeito apenas a "pular a inicialização" (ISO C ++ '03 6.7 / 3)

Muitas postagens aqui mencionaram que pular a declaração pode resultar na variável "não sendo declarada". Isso não é verdade. Um objeto POD pode ser declarado sem um inicializador, mas terá um valor indeterminado. Por exemplo:

switch (i)
{
   case 0:
     int j; // 'j' has indeterminate value
     j = 0; // 'j' initialized to 0, but this statement
            // is jumped when 'i == 1'
     break;
   case 1:
     ++j;   // 'j' is in scope here - but it has an indeterminate value
     break;
}

Onde o objeto é um não-POD ou agregado, o compilador adiciona implicitamente um inicializador e, portanto, não é possível pular essa declaração:

class A {
public:
  A ();
};

switch (i)  // Error - jumping over initialization of 'A'
{
   case 0:
     A j;   // Compiler implicitly calls default constructor
     break;
   case 1:
     break;
}

Essa limitação não está limitada à instrução switch. Também é um erro usar 'goto' para pular uma inicialização:

goto LABEL;    // Error jumping over initialization
int j = 0; 
LABEL:
  ;

Um pouco de trivialidade é que essa é uma diferença entre C ++ e C. Em C, não é um erro pular a inicialização.

Como outros já mencionaram, a solução é adicionar um bloco aninhado para que o tempo de vida da variável seja limitado ao rótulo de caso individual.

Toda a instrução switch está no mesmo escopo. Para contornar isso, faça o seguinte:

switch (val)
{
    case VAL:
    {
        // This **will** work
        int newVal = 42;
    }
    break;

    case ANOTHER_VAL:
      ...
    break;
}

Observe os colchetes.

Depois de ler todas as respostas e mais algumas pesquisas, recebo algumas coisas.

Case statements are only 'labels'

Em C, de acordo com a especificação,

§6.8.1 Declarações rotuladas:

labeled-statement:
    identifier : statement
    case constant-expression : statement
    default : statement

Em C, não há nenhuma cláusula que permita uma "declaração rotulada". Simplesmente não faz parte do idioma.

assim

case 1: int x=10;
        printf(" x is %d",x);
break;

Isso não será compilado , consulte http://codepad.org/YiyLQTYw . O GCC está dando um erro:

label can only be a part of statement and declaration is not a statement

Até

  case 1: int x;
          x=10;
            printf(" x is %d",x);
    break;

isso também não está sendo compilado , consulte http://codepad.org/BXnRD3bu . Aqui também estou recebendo o mesmo erro.

Em C ++, de acordo com a especificação,

A declaração etiquetada é permitida, mas a inicialização rotulada não é permitida.

Veja http://codepad.org/ZmQ0IyDG .

A solução para essa condição é dois

1. Use o novo escopo usando {}

   case 1:
          {
              int x=10;
              printf(" x is %d", x);
          }
   break;

2. Ou use uma declaração fictícia com etiqueta

   case 1: ;
              int x=10;
              printf(" x is %d",x);
   break;

3. Declare a variável antes de switch () e inicialize-a com valores diferentes na instrução case, se ela atender aos seus requisitos

   main()
   {
       int x;   // Declare before
       switch(a)
       {
       case 1: x=10;
           break;
   
       case 2: x=20;
           break;
       }
   }

Mais algumas coisas com a instrução switch

Nunca escreva nenhuma declaração no comutador que não faça parte de nenhum rótulo, porque elas nunca serão executadas:

switch(a)
{
    printf("This will never print"); // This will never executed

    case 1:
        printf(" 1");
        break;

    default:
        break;
}

Veja http://codepad.org/PA1quYX3 .

Você não pode fazer isso, porque os caserótulos são na verdade apenas pontos de entrada no bloco que o contém.

Isso é mais claramente ilustrado pelo dispositivo de Duff . Aqui está um código da Wikipedia:

strcpy(char *to, char *from, size_t count) {
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    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);
    }
}

Observe como os caserótulos ignoram totalmente os limites do bloco. Sim, isso é mau. Mas é por isso que seu exemplo de código não funciona. Saltar para um caserótulo é o mesmo que usar goto, portanto, você não pode saltar sobre uma variável local com um construtor.

Como vários outros pôsteres indicaram, você precisa colocar um bloco de sua preferência:

switch (...) {
    case FOO: {
        MyObject x(...);
        ...
        break; 
    }
    ...
 }

A maioria das respostas até agora estão erradas em um aspecto: você pode declarar variáveis ​​após a instrução case, mas não pode inicializá-las:

case 1:
    int x; // Works
    int y = 0; // Error, initialization is skipped by case
    break;
case 2:
    ...

Como mencionado anteriormente, uma boa maneira de contornar isso é usar chaves para criar um escopo para o seu caso.

Meu truque favorito de troca de mal é usar um if (0) para pular um rótulo de caixa indesejado.

switch(val)
{
case 0:
// Do something
if (0) {
case 1:
// Do something else
}
case 2:
// Do something in all cases
}

Mas muito mal.

Tente o seguinte:

switch (val)
{
    case VAL:
    {
        int newVal = 42;
    }
    break;
}

Você pode declarar variáveis ​​em uma instrução switch se iniciar um novo bloco:

switch (thing)
{ 
  case A:
  {
    int i = 0;  // Completely legal
  }
  break;
}

O motivo está relacionado à alocação (e recuperação) de espaço na pilha para armazenamento das variáveis ​​locais.

Considerar:

switch(val)
{
case VAL:
   int newVal = 42;
default:
   int newVal = 23;
}

Na ausência de instruções de interrupção, às vezes o newVal é declarado duas vezes e você não sabe se o faz até o tempo de execução. Meu palpite é que a limitação se deve a esse tipo de confusão. Qual seria o escopo do newVal? A Convenção ditaria que seria o bloco inteiro do interruptor (entre os aparelhos).

Eu não sou programador C ++, mas em C:

switch(val) {
    int x;
    case VAL:
        x=1;
}

Funciona bem. Declarar uma variável dentro de um bloco de chave é bom. Declarar após uma guarda de caso não é.

A seção inteira do switch é um único contexto de declaração. Você não pode declarar uma variável em uma declaração de caso como essa. Tente isso:

switch (val)  
{  
case VAL:
{
  // This will work
  int newVal = 42;
  break;
}
case ANOTHER_VAL:  
  ...
  break;
}

Se o seu código diz "int newVal = 42", você esperaria razoavelmente que o newVal nunca seja não inicializado. Mas se você passar por cima dessa declaração (que é o que você está fazendo), é exatamente isso que acontece - newVal está no escopo, mas não foi atribuído.

Se é isso que você realmente queria que acontecesse, o idioma exige que seja explicitado dizendo "int newVal; newVal = 42;". Caso contrário, você pode limitar o escopo de newVal ao caso único, o que é mais provável do que você queria.

Pode esclarecer as coisas se você considerar o mesmo exemplo, mas com "const int newVal = 42;"

Eu só queria enfatizar o ponto de Slim . Uma construção de switch cria um escopo completo para o cidadão de primeira classe. Portanto, é possível declarar (e inicializar) uma variável em uma instrução switch antes do primeiro rótulo do caso, sem um par de colchetes adicional:

switch (val) {  
  /* This *will* work, even in C89 */
  int newVal = 42;  
case VAL:
  newVal = 1984; 
  break;
case ANOTHER_VAL:  
  newVal = 2001;
  break;
}

Até agora, as respostas foram para C ++.

Para C ++, você não pode pular uma inicialização. Você pode em C. No entanto, em C, uma declaração não é uma declaração e os rótulos de caso devem ser seguidos por declarações.

Então, C válido (mas feio), C ++ inválido

switch (something)
{
  case 1:; // Ugly hack empty statement
    int i = 6;
    do_stuff_with_i(i);
    break;
  case 2:
    do_something();
    break;
  default:
    get_a_life();
}

Por outro lado, em C ++, uma declaração é uma declaração, portanto, o seguinte é C ++ válido, C inválido

switch (something)
{
  case 1:
    do_something();
    break;
  case 2:
    int i = 12;
    do_something_else();
}

Interessante que isso seja bom:

switch (i)  
{  
case 0:  
    int j;  
    j = 7;  
    break;  

case 1:  
    break;
}

... mas isso não é:

switch (i)  
{  
case 0:  
    int j = 7;  
    break;  

case 1:  
    break;
}

Entendo que uma correção é bastante simples, mas ainda não estou entendendo por que o primeiro exemplo não incomoda o compilador. Como foi mencionado anteriormente (2 anos antes hehe), a declaração não é o que causa o erro, apesar da lógica. Inicialização é o problema. Se a variável for inicializada e declarada nas diferentes linhas, ela será compilada.

Eu escrevi esta resposta original para esta pergunta . No entanto, quando terminei, descobri que a resposta estava fechada. Então, eu publiquei aqui, talvez alguém que goste de referências ao padrão ache isso útil.

Código original em questão:

int i;
i = 2;
switch(i)
{
    case 1: 
        int k;
        break;
    case 2:
        k = 1;
        cout<<k<<endl;
        break;
}

Na verdade, existem 2 perguntas:

1. Por que posso declarar uma variável após o caserótulo?

É porque no rótulo C ++ deve estar no formato:

N3337 6.1 / 1

declaração rotulada:

...

• atributo-especificador-seqopt case constant-expression :statement

...

E na C++ declaração, a declaração também é considerada como declaração (em oposição a C):

N3337 6/1:

declaração :

...

declaração-declaração

...

2. Por que posso pular a declaração de variável e depois usá-la?

Porque: N3337 6,7 / 3

É possível transferir para um bloco, mas não de uma maneira que ignore as declarações com a inicialização . Um programa que salta (A transferência da condição de uma instrução switch para um rótulo de caso é considerada um salto a esse respeito.)

de um ponto em que uma variável com duração de armazenamento automática não está no escopo a um ponto em que está no escopo está mal formada , a menos que a variável tenha tipo escalar , tipo de classe com um construtor padrão trivial e um destruidor trivial, uma versão qualificada para cv de um desses tipos ou uma matriz de um dos tipos anteriores e é declarado sem um inicializador (8.5).

Como ké do tipo escalar e não é inicializado no ponto da declaração, é possível saltar sobre sua declaração. Isso é semanticamente equivalente:

goto label;

int x;

label:
cout << x << endl;

No entanto, isso não seria possível, se xfoi inicializado no ponto da declaração:

 goto label;

    int x = 58; //error, jumping over declaration with initialization

    label:
    cout << x << endl;

Novas variáveis ​​podem ser decalcadas apenas no escopo do bloco. Você precisa escrever algo como isto:

case VAL:  
  // This will work
  {
  int newVal = 42;  
  }
  break;

Obviamente, o newVal só tem escopo dentro do aparelho ...

Cheers, Ralph

Um switchbloco não é o mesmo que uma sucessão de if/else ifblocos.Estou surpreso que nenhuma outra resposta explique claramente.

Considere esta switchdeclaração:

switch (value) {
    case 1:
        int a = 10;
        break;
    case 2:
        int a = 20;
        break;
}

Pode ser surpreendente, mas o compilador não o verá como simples if/else if. Ele produzirá o seguinte código:

if (value == 1)
    goto label_1;
else if (value == 2)
    goto label_2;
else
    goto label_end;

{
label_1:
    int a = 10;
    goto label_end;
label_2:
    int a = 20; // Already declared !
    goto label_end;
}

label_end:
    // The code after the switch block

As caseinstruções são convertidas em rótulos e depois chamadas com goto. Os colchetes criam um novo escopo e é fácil ver agora por que você não pode declarar duas variáveis ​​com o mesmo nome em umswitch bloco.

Pode parecer estranho, mas é necessário oferecer suporte a falhas (ou seja, não usar breakpara permitir que a execução continue na próxima case).

Acredito que o problema em questão é que a declaração foi ignorada e você tentou usar o var em outro lugar, não seria declarado.

newVal existe em todo o escopo do comutador, mas só é inicializado se o membro VAL for atingido. Se você criar um bloco ao redor do código em VAL, deverá estar OK.

O padrão C ++ possui: É possível transferir para um bloco, mas não de maneira a ignorar as declarações com a inicialização. Um programa que salta de um ponto em que uma variável local com duração de armazenamento automática não está no escopo para um ponto em que está no escopo está mal formada, a menos que a variável tenha o tipo POD (3.9) e seja declarada sem um inicializador (8.5).

O código para ilustrar esta regra:

#include <iostream>

using namespace std;

class X {
  public:
    X() 
    {
     cout << "constructor" << endl;
    }
    ~X() 
    {
     cout << "destructor" << endl;
    }
};

template <class type>
void ill_formed()
{
  goto lx;
ly:
  type a;
lx:
  goto ly;
}

template <class type>
void ok()
{
ly:
  type a;
lx:
  goto ly;
}

void test_class()
{
  ok<X>();
  // compile error
  ill_formed<X>();
}

void test_scalar() 
{
  ok<int>();
  ill_formed<int>();
}

int main(int argc, const char *argv[]) 
{
  return 0;
}

O código para mostrar o efeito inicializador:

#include <iostream>

using namespace std;

int test1()
{
  int i = 0;
  // There jumps fo "case 1" and "case 2"
  switch(i) {
    case 1:
      // Compile error because of the initializer
      int r = 1; 
      break;
    case 2:
      break;
  };
}

void test2()
{
  int i = 2;
  switch(i) {
    case 1:
      int r;
      r= 1; 
      break;
    case 2:
      cout << "r: " << r << endl;
      break;
  };
}

int main(int argc, const char *argv[]) 
{
  test1();
  test2();
  return 0;
}

Parece que objetos anônimos podem ser declarados ou criados em uma instrução de caso de opção pelo motivo de não poderem ser referenciados e, como tal, não passarem para o próximo caso. Considere este exemplo de compilação no GCC 4.5.3 e no Visual Studio 2008 (pode ser um problema de conformidade, por isso os especialistas devem avaliar)

#include <cstdlib>

struct Foo{};

int main()
{
    int i = 42;

    switch( i )
    {
    case 42:
        Foo();  // Apparently valid
        break;

    default:
        break;
    }
    return EXIT_SUCCESS;
}