Why can local class definitions access outside static variables from the same function?

Question

Observe the following:

#include <iostream>
#include <string>
#include <cstdlib>

int main(){

    static std::string foo = "inside main";

    struct Bar{
        Bar(){
            std::cout << "I can see " << foo << '\n';
        }
    };

    Bar b;

    return EXIT_SUCCESS;
}

The output of this program is: "I can see inside main".

Why can the class constructor look outside the class definition and find foo?

It only works, if foo is static, inside the same function as the class definition, and comes before the class definition.

---

Help convince me that it's not violating the rules of scope. Why is it possible? What are the advantages and pitfalls of such an implementation?

Answer 1

Because struct Bar is inside main()'s namespace and foo is static. The standard says:

A class can be defined within a function definition; such a class is called a local class. The name of a local class is local to its enclosing scope. The local class is in the scope of the enclosing scope, and has the same access to names outside the function as does the enclosing function. Declarations in a local class can use only type names, static variables, extern variables and functions, and enumerators from the enclosing scope.

So your code doesn't violate the standard.