c# - tener - personas con doble personalidad como se llaman

¿El ámbito variable del contador de bucles parece tener una doble personalidad?

Question

Esta pregunta ya tiene una respuesta aquí:

• Confusión de alcance variable en C # 4 respuestas

El código siguiente produce este error en Visual Studio 2012; "Una variable local llamada ''x'' no se puede declarar en este ámbito porque daría un significado diferente a ''x'', que ya se usa en un alcance ''secundario'' para denotar algo más"

for (int x = 0; x < 9; x++) 
  {
     //something
  }
int x = 0;

Sin embargo. Cuando se modifica como a continuación, obtengo este error; "El nombre ''x'' no existe en el contexto actual"

for (int x = 0; x < 9; x++) 
  {
     //something
  }
x = 0;

¿Es esto una gran contradicción o me estoy perdiendo algo?

Answer 1

C # le impide crear una situación confusa en la que es fácil cometer errores sobre a qué se refiere x realmente.

Answer 2

El primero es un error porque es equivalente a esto:

int x;
for (int x = 0; x < 9; x++) 
{
   //something
   // ''x'' is ambiguous here
}
x = 0;

La forma en que funcionan las declaraciones de variables en C #, es lo mismo que su primera muestra.

El segundo es un error porque la variable ''x'' definida en el ciclo solo es válida en el ciclo.

Answer 3

Es debido al alcance del niño.

Lo siguiente no funcionará ya que ambos i''s estoy en el mismo alcance

for (int i = 0; i < 100; i++)
{
    Console.WriteLine(i);
}

int i = 10;
Console.WriteLine(i);

Lo siguiente tampoco funcionará, ya que ambas i''s están todavía en el mismo alcance

{
    for (int i = 0; i < 100; i++)
    {
        Console.WriteLine(i);
    }
}
int i = 10;
Console.WriteLine(i);

Lo siguiente funcionará bien

{
    for (int i = 0; i < 100; i++)
    {
        Console.WriteLine(i);
    }
}
{
    int i = 10;
    Console.WriteLine(i);
}

Answer 4

Hasta el momento, nadie excepto Rik ha puesto su dedo sobre la respuesta correcta.

Lee los mensajes de error nuevamente, con mucho cuidado. Están explicando claramente los errores. El primer error es:

Una variable local llamada ''x'' no se puede declarar en este ámbito porque daría un significado diferente a ''x'', que ya se usa en un ámbito ''secundario'' para denotar algo más

En realidad, lea el mensaje de error. Dice que es ilegal usar el mismo nombre para referirse a dos cosas diferentes . El error no tiene nada que ver con el alcance de la x externa per se; tiene que ver con el hecho de que x se usa para referirse a dos cosas en el mismo ámbito externo .

Como señala Rik, el propósito de esta regla es evitar situaciones en las que el desarrollador se confunde con el significado de x . Un nombre de pila casi siempre significa lo mismo en un bloque. (Hay algunas excepciones sutiles, pero no profundicemos en ellas hoy). Esta regla también ayuda a prevenir errores introducidos al reordenar declaraciones dentro de un método y, por lo tanto, cambiar sutilmente el significado de los nombres. Si el significado de un nombre es invariante dentro de un bloque, entonces las ediciones de código dentro de ese bloque se pueden hacer con confianza.

Varias de las respuestas dicen que los ámbitos no se pueden superponer. Sí lo son. Los ámbitos de variables locales no se pueden superponer, pero los ámbitos se pueden superponer. Por ejemplo:

class C
{
    int x;
    void M()
    {
        int y = this.x;
        for(int x = 0; x < 10; ++x) {}
    }
}

Perfectamente legal a pesar de que hay dos cosas llamadas x en el alcance al mismo tiempo. Pero esto no es legal:

class C
{
    int x;
    void M()
    {
        int y = x; // Means this.x
        for(int x = 0; x < 10; ++x) {} // means local x
    }
}

Ahora el nombre simple x significa dos cosas diferentes dentro del cuerpo de M, y eso es lo que es ilegal. De nuevo, asegúrese de entender esto: usar el mismo nombre para significar dos cosas en el mismo alcance es lo que es ilegal . No es ilegal superponer ámbitos.

Ahora tu segundo error:

"El nombre ''x'' no existe en el contexto actual"

El nombre x solo es válido dentro de la declaración for . Una declaración de:

for (declarations ; condition ; increment ) body

es lógicamente equivalente (modulo break y continuar el comportamiento) a

{
    declarations;
    while(condition)
    {
        body
        increment
    } 
}

Tenga en cuenta las llaves externas. Cualquier cosa en esa declaración se puede usar a través de la condición, cuerpo o incremento, pero no está fuera del alcance.

Answer 5

La variable x es nuestro alcance porque fue declarada en el ciclo. Si de todos modos desea usar la misma variable nuevamente, intente esto - (No recomendado, sin embargo, estándares)

int x = 0;
for (x = 0; x < 9; x++){
//something
}
x = 0;

Answer 6

No es una contradicción la int x que define en for tiene un alcance para el ciclo for, lo que significa:

for (int x = 0; x < 9; x++) 
{
    //x is only alive here.
}

//you can''t use it here.

sin embargo, no puede crear otra variable x en un ámbito principal (es decir, el alcance del método):

public void MyMethod()
{
   int x = 0; //method-scoped variable.

    for (int x = 0; x < 9; x++)  //for-scoped variable, with the same name, invalid.
    {
        //here you have 2 "x", which one to use? invalid.
    }

   //the first x is available here
}

Answer 7

Una serie de instrucciones rodeadas de llaves forman un bloque de código. Un cuerpo de método es un ejemplo de un bloque de código. Los bloques de código a menudo siguen una instrucción de control. Las variables o constantes declaradas dentro de un bloque de código solo están disponibles para las sentencias dentro del mismo bloque de código.

Consulte este enlace: http://msdn.microsoft.com/en-us/library/ms173143%28v=vs.80%29.aspx

Haciendo esto:

for (int x = 0; x < 9; x++) 
  {
     //something
  }
x = 0;

Es detectado por el analizador semántico como un error, porque x ya no está disponible fuera del ciclo for.

Aunque cuando haces una int x dentro de un bloque interno y declaras una int x fuera del bloque interno, el compilador te advierte solo sobre un posible error en tu semántica.

for (int x = 0; x < 9; x++) 
  {
     //something
  }

//theoretically allowed, but the C# compiler identifies it as an error.
int x = 0; //caution x declare before

Si estás intrigado por esto, la explicación es bastante simple:

Como se indica en la sección 3.7 de la especificación de idioma. "El alcance de una variable local declarada en una declaración de variable local (8.5.1) es el bloque en el que se produce la declaración".

El alcance de x es, por lo tanto, la función completa donde lo declaró, y eso significa que la declaración / uso fuera del ciclo for es un re = uso, y por lo tanto no está permitido.

Este comportamiento está destinado a hacer menos probable la reutilización incorrecta de nombres de variables (como cortar y pegar).

Saludos.