c# - que - sobrecarga operador corchete c++

C#Cambio de declaración con/sin llaves... ¿cuál es la diferencia?

Question

¿Ha permitido siempre C # omitir las llaves entre una declaración switch() entre las declaraciones case: :?

¿Cuál es el efecto de omitirlos, como suelen hacer los programadores de JavaScript?

Ejemplo:

switch(x)
{
  case OneWay:
  {                               //  <---- Omit this entire line
    int y = 123;
    FindYou(ref y);
    break;
  }                               //  <---- Omit this entire line
  case TheOther:
  {                               //  <---- Omit this entire line
    double y = 456.7; // legal!
    GetchaGetcha(ref y);
    break;
  }                               //  <---- Omit this entire line
}

Answer 1

Las llaves dentro del interruptor en realidad no son parte de la estructura del interruptor en absoluto. Son solo bloques de alcance, que puede aplicar en el código en cualquier lugar que desee.

La diferencia entre tenerlos y no tenerlos es que cada bloque tiene su propio alcance. Puede declarar variables locales dentro del alcance, que no entren en conflicto con otras variables en otro ámbito.

Ejemplo:

int x = 42;
{
  int y = x;
}
{
  int y = x + 1; // legal, as it''s in a separate scope
}

Answer 2

Las llaves son una parte opcional del bloque del interruptor , no son parte de las secciones del interruptor. Las llaves se pueden insertar dentro de las secciones de interruptor o se pueden insertar igualmente en cualquier lugar para controlar el alcance en su código.

Pueden ser útiles para limitar el alcance dentro del bloque de conmutadores. Por ejemplo:

int x = 5;

switch(x)
{
case 4:
    int y = 3;
    break;
case 5:
    y = 4;
    //...                      
    break;
}

vs ...

int x = 5;

switch(x)
{
  case 4:
  {
    int y = 3;
    break;
  }
  case 5:
  {
    y = 4;//compiling error
    //...                      
    break;
  }
}

Nota: C # requerirá que establezca un valor en y dentro del bloque de mayúsculas y minúsculas en el primer ejemplo antes de usarlo. Esta es la protección contra el seguimiento de variables accidentales.

Answer 3

No se requieren llaves, pero pueden ser útiles para introducir un nuevo espacio de declaración . Este comportamiento no ha cambiado desde C # 1.0 hasta donde yo sé.

El efecto de omitirlos es que todas las variables declaradas en algún lugar dentro de la sentencia switch son visibles desde su punto de declaración en todas las ramas de casos.

Ver también el ejemplo de Eric Lippert (caso 3 en la publicación):

Cuatro rarezas de interruptor

El ejemplo de Eric:

switch(x)
{
  case OneWay:
    int y = 123;
    FindYou(ref y);
    break;
  case TheOther:
    double y = 456.7; // illegal!
    GetchaGetcha(ref y);
    break;
}

Esto no se compila porque int y y double y están en el mismo espacio de declaración introducido por la instrucción switch . Puede corregir el error separando los espacios de declaración usando llaves:

switch(x)
{
  case OneWay:
  {
    int y = 123;
    FindYou(ref y);
    break;
  }
  case TheOther:
  {
    double y = 456.7; // legal!
    GetchaGetcha(ref y);
    break;
  }
}

Answer 4

No son estrictamente necesarios, pero tan pronto como comience a declarar variables locales (en las ramas de cambio) son muy recomendables.

Esto no funcionará:

    // does not compile
    switch (x)
    {
        case 1 :               
            int j = 1;
            ...
            break;

        case 3:
            int j = 3;   // error
            ...
            break;
    }

Esto compila pero es espeluznante:

    switch (x)
    {
        case 1 :               
            int j = 1;
            ...
            break;

        case 3:
            j = 3;
            ...
            break;
    }

Entonces esto es lo mejor:

  switch (x)
    {
        case 1 : 
         {             
            int j = 1;
            ...
         }
         break;  // I prefer the break outside of the  { }

        case 3: 
         {
            int j = 3;
            ...
         }
         break;
    }

Simplemente mantenlo simple y legible. No desea obligar a los lectores a tener un conocimiento detallado de las reglas involucradas en el ejemplo del medio.