Name hiding through nesting can occur as a result of nesting namespaces or types within namespaces, as a result of nesting types within classes or structs, and as a result of parameter and local variable declarations. Name hiding through nesting of scopes always occurs "silently", i.e. no errors or warnings are reported when outer names are hidden by inner names.
In the example
class A { int i = 0; void F() { int i = 1; } void G() { i = 1; } }
within the F
method, the instance variable i
is hidden by the local variable i
, but within the G
method, i
still refers to the instance variable.
When a name in an inner scope hides a name in an outer scope, it hides all overloaded occurrences of that name. In the example
class Outer { static void F(int i) {} static void F(string s) {} class Inner { void G() { F(1); // Invokes Outer.Inner.F F("Hello"); // Error } static void F(long l) {} } }
the call F(1)
invokes the F
declared in Inner
because all outer occurrences of F
are hidden by the inner declaration. For the same reason, the call F("Hello")
is in error.