Warum können keine Variablen deklariert werden, die in einer switch-Anweisung?

Case Aussagen sind nur Etiketten. Dies bedeutet, dass der compiler interpretiert dies als ein Klick direkt auf das Etikett. In C++, das problem hier ist einer der Rahmen. Ihre geschweiften Klammern definieren den Bereich als alles in der switch - Anweisung. Dies bedeutet, dass Sie mit Links sind ein Bereich, wo ein Sprung ausgeführt werden, weiter in den code überspringen der Initialisierung. Der richtige Umgang mit diesen ist für die Definition eines Bereichs spezifische case - Anweisung und definieren Sie Ihre Variablen innerhalb von.

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

InformationsquelleAutor TJ Seabrooks

Ok. Nur um dies zu verdeutlichen streng nichts zu tun hat mit der Erklärung. Es bezieht sich nur auf "einen Sprung über die Initialisierung" (ISO C++ '03 6.7/3)

Viele der Beiträge hier haben erwähnt, dass springen über die Erklärung kann Ergebnis in der variable "nicht deklariert". Das ist nicht wahr. Ein POD-Objekt deklariert werden kann ohne Initialisierer, aber es wird ein unbestimmter Wert. Zum Beispiel:

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;
}

Wo das Objekt ist ein nicht-POD oder ein Aggregat der compiler implizit Hinzugefügt einen Initialisierer, und so ist es nicht möglich, springen über solch eine Erklärung:

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;
}

Diese Einschränkung ist nicht nur auf die switch-Anweisung. Es ist auch ein Fehler für die Verwendung von 'springen', springen über eine Initialisierung:

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

Ein bisschen trivia ist, dass dies einen Unterschied zwischen C++ und C. In C ist es kein Fehler, springe über die Initialisierung.

Wie andere erwähnt haben, die Lösung ist das hinzufügen einer verschachtelten block, so dass die Lebensdauer von Variablen beschränkt sich auf den einzelnen Fall label.

InformationsquelleAutor Richard Corden

Nach der Lektüre alle Antworten und einige mehr Forschung, ich ein paar Sachen besorgen.

Case statements are only 'labels'

In C, entsprechend der Spezifikation,

§6.8.1 Labeled Statements:

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

In C gibt es keine Klausel, die ermöglicht, dass eine "beschriftet Erklärung". Es ist einfach nicht Teil der Sprache.

So

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

Diese wird nicht kompiliert, siehe http://codepad.org/YiyLQTYw. GCC gibt eine Fehlermeldung:

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

Sogar

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

dies ist auch nicht kompilieren, siehe http://codepad.org/BXnRD3bu. Hier bin ich auch immer die gleichen Fehler.

In C++, die nach der Spezifikation,

beschriftet-Deklaration ist erlaubt, aber beschriftet -Initialisierung ist nicht erlaubt.

Sehen http://codepad.org/ZmQ0IyDG.

Lösung für diese Bedingung ist, zwei

1. Entweder neue Bereich mit {}

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

2. Oder verwenden Sie dummy-Anweisung mit label

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

3. Deklarieren Sie die variable vor dem Schalter (), und initialisieren Sie es mit verschiedenen Werten in case-Anweisung, wenn Sie erfüllt Ihre Anforderung

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

Einige weitere Dinge, die mit der switch-Anweisung

Nie schreiben, Aussagen auf den Schalter, die nicht Teil von jedem Etikett, da Sie nie ausgeführt wird:

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

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

    default:
        break;
}

Sehen http://codepad.org/PA1quYX3.

InformationsquelleAutor Jeegar Patel

Meisten Antworten bisher sind falsch in einer Hinsicht: Sie kann Variablen deklarieren, die nach der case-Anweisung, aber Sie nicht initialisieren:

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

Wie bereits erwähnt, ein schöner Weg, um dieses ist die Verwendung von Klammern, um einen Bereich erstellen für Ihren Fall.

InformationsquelleAutor MrZebra

Versuchen Sie dies:

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

InformationsquelleAutor Dan Shield

Betrachten:

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

In der Abwesenheit von break-Anweisungen, manchmal newVal bekommt erklärt, zweimal, und Sie nicht wissen, ob es nicht erst zur Laufzeit. Meine Vermutung ist, dass die Beschränkung wegen dieser Art von Verwirrung. Was würde der Umfang der newVal werden? Übereinkommen diktieren würde, wäre es der gesamte switch-block (in geschweiften Klammern).

Ich bin kein C++ Programmierer, aber in C:

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

Funktioniert einwandfrei. Die Deklaration einer Variablen innerhalb eines switch-Blocks ist in Ordnung. Deklarieren nach einer case-guard nicht.

InformationsquelleAutor slim

Wenn Ihr code sagt, "int newVal=42", dann würde man vernünftigerweise erwarten, dass newVal ist nie uninitialised. Aber wenn Sie springen über diese Aussage (was du tust) dann ist das genau das, was passiert - newVal ist in-Bereich, hat aber noch nicht zugewiesen wurde.

Wenn das ist, was Sie wirklich passieren sollte dann wird die Sprache benötigt, um es explizit mit den Worten "int newVal; newVal = 42;". Ansonsten können Sie den Umfang der newVal um den einzigen Fall, das ist eher das, was Sie wollte.

Kann es klären sich Dinge, wenn Sie denken, das gleiche Beispiel, aber mit "const int newVal = 42;"

InformationsquelleAutor

Bisher die Antworten wurden für C++.

Für C++, Sie können nicht springen über eine Initialisierung. Sie können in C. Aber in C, eine Deklaration ist keine Anweisung und case-labels zu sein, gefolgt von Anweisungen.

So, gültig (aber hässlich) C, ungültig C++

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();
}

Conversly, in C++, eine Deklaration ist eine Anweisung, so gilt C++, ungültig C

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

InformationsquelleAutor Peter

Schrieb ich diese Antwort ursprünglich für diese Frage. Aber als ich es beendet hatte, fand ich, dass die Antwort geschlossen wurde. So habe ich es hier gepostet, vielleicht jemand, der gerne Referenzen zu standard wird es hilfreich.

Original-Code in Frage:

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

Gibt es eigentlich 2 Fragen:

1. Warum kann ich eine variable deklarieren, die nach case label?

Ist es, weil in C++ - label werden in der form:

N3337 6.1/1

labeled-statement:

...

• Attribut-Bezeichner-seqopt case constant-expression : statement

...

Und in C++ Erklärung Erklärung wird auch als Anweisung (im Gegensatz zu C):

N3337 6/1:

Anweisung:

...

Erklärung-Erklärung

...

2. Warum kann ich springen über die Deklaration von Variablen und verwenden Sie es dann?

Weil:
N3337 6.7/3

Ist es möglich, die übertragung in einen block, aber nicht in einer Weise umgeht, die Deklarationen mit Initialisierung. Ein
das Programm springt
(Die transfer von den Zustand eines switch-Anweisung nach einer case-Bezeichnung als ein Sprung in dieser Hinsicht.)

aus einem Punkt, wo eine variable mit automatischer Speicherdauer ist nicht im Umfang bis zu einem Punkt, wo es im Rahmen ist schlecht ausgebildet , es sei denn, die variable hat skalaren Typ, Klasse Typ mit einer trivialen Standard
Konstruktor und eine trivial destructor, eine cv-qualifizierte version von einer dieser Arten, oder eine Reihe von eine der
vorhergehenden Arten und erklärt wird, ohne eine Initialisierung (8.5).

Seit k ist skalaren Typ, und ist nicht initialisiert, an der Stelle der Deklaration springen über es in der Erklärung ist möglich. Dies ist semantisch äquivalent:

goto label;

int x;

label:
cout << x << endl;

Jedoch, dass wäre nicht möglich, wenn x initialisiert wurde an der Stelle der Erklärung:

 goto label;

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

    label:
    cout << x << endl;

InformationsquelleAutor PcAF

Einen switch block ist nicht das gleiche wie eine Abfolge von if/else if Blöcke. Ich bin überrascht, dass keine andere Antwort erklärt es eindeutig.

Betrachten Sie diese switch Aussage :

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

Kann es überraschend sein, aber der compiler wird es nicht als eine einfache if/else if. Es ergibt folgenden code :

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

Den case - Anweisungen umgewandelt werden, die Etiketten und rief dann mit goto. Die Klammern erstellen einen neuen Bereich, und es ist leicht zu sehen jetzt, warum Sie nicht deklarieren Sie zwei Variablen mit demselben Namen innerhalb einer switch block.

Kann es seltsam Aussehen, aber es ist notwendig, zu unterstützen fallthrough (das heißt, nicht mit break zu lassen, die Ausführung weiter zum nächsten case).

InformationsquelleAutor Dalmas

C++ - Standard hat:
Es ist möglich, den transfer in einen block, aber nicht in einer Weise umgeht, die Deklarationen mit Initialisierung. Ein Programm, springt von einem Punkt, wo eine lokale variable mit automatischer Speicherdauer ist nicht im Umfang bis zu einem Punkt, wo es im Rahmen ist schlecht ausgebildet, es sei denn, die variable POD-Typ (3.9) und erklärt wird, ohne eine Initialisierung (8.5).

Den code verdeutlichen diese Regel:

#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;
}

Den code zu zeigen, der Initialisierer-Effekt:

#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;
}

InformationsquelleAutor Jingguo Yao

Scheint es, dass anonyme Objekte kann deklariert werden oder in einer switch-case-Anweisung aus dem Grund, dass Sie können nicht referenziert werden und als solche nicht fallen, die durch das nächste case. Betrachten Sie dieses Beispiel kompiliert auf GCC 4.5.3 und Visual Studio 2008 (möglicherweise ein compliance-Problem tho', so die Experten bitte Wiegen)

#include <cstdlib>

struct Foo{};

int main()
{
    int i = 42;

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

    default:
        break;
    }
    return EXIT_SUCCESS;
}

InformationsquelleAutor Olumide