En C++, ¿cuál es la resolución del alcance("orden de precedencia") para nombres de variables sombreados?

scope shadowing

Question

En C ++, ¿cuál es la resolución del alcance ("orden de precedencia") para nombres de variables sombreados ? Parece que no puedo encontrar una respuesta concisa en línea.

Por ejemplo:

#include <iostream>

int shadowed = 1;

struct Foo
{
    Foo() : shadowed(2) {}

    void bar(int shadowed = 3)
    {
        std::cout << shadowed << std::endl;
            // What does this output?

        {
            int shadowed = 4;
            std::cout << shadowed << std::endl;
                // What does this output?
        }
    }

    int shadowed;
};


int main()
{
    Foo().bar();
}

No puedo pensar en ningún otro ámbito donde una variable pueda entrar en conflicto. Por favor, avíseme si me perdí una.

¿Cuál es el orden de prioridad para las cuatro variables shadow cuando está dentro de la función de miembro de la bar ?

Answer 1

Debería imprimir 3. La regla básica es principalmente avanzar hacia atrás a través del archivo hasta la definición más reciente que el compilador habría visto (editar: que no ha salido del alcance), y eso es lo que usa. Para variables que son locales para una clase, usted sigue el mismo, excepto que todas las variables de clase se tratan como si estuvieran definidas al comienzo de la definición de clase. Sin embargo, tenga en cuenta que esto es más o menos exclusivo de las clases. Por ejemplo, un código dado como:

int i;

int x() { 
    std::cout << i << ''/n''; // prints 0;
    int i=1;
}

A pesar de que hay un i que es local para la función, la definición más reciente que se ve en donde se usa cout es global, entonces eso es a lo que se refiere el i en esa expresión. Si, sin embargo, esto era en una clase:

int i;

class X { 
    void y() { std::cout << i << "/n"; }

    X() : i(2) {}

    int i;
};

Entonces, la expresión cout se referiría a X::i aunque su definición aún no se haya visto cuando se está analizando y.

Answer 2

Sus primeras salidas de ejemplo 3. Sus segundas salidas 4.

La regla general es que la búsqueda procede de la variable "más local" a la "menos local". Por lo tanto, la precedencia aquí es block -> local -> class -> global.

También puede acceder a cada una de las versiones de la variable sombreada explícitamente:

// See http://ideone.com/p8Ud5n
#include <iostream>

int shadowed = 1;

struct Foo
{
    int shadowed;
    Foo() : shadowed(2) {}
    void bar(int shadowed = 3);
};

void Foo::bar(int shadowed)
{
    std::cout << ::shadowed << std::endl; //Prints 1
    std::cout << this->shadowed << std::endl; //Prints 2
    std::cout << shadowed << std::endl; //Prints 3
    {
        int shadowed = 4;
        std::cout << ::shadowed << std::endl; //Prints 1
        std::cout << this->shadowed << std::endl; //Prints 2
        //It is not possible to print the argument version of shadowed
        //here.
        std::cout << shadowed << std::endl; //Prints 4
    }
}

int main()
{
    Foo().bar();
}