C++ Shadowing – Does a Constructor Parameter of a Nested Class Shadow Members of the Enclosing Class?

c++inner-classesshadowing

class A
{
  private:
    int a;

  public:
    class B
    {
      public:
        B(int a) : b(a) {}

        int b;
    };
};


int main(void)
{
  return 0;
}

clang (-Weverything) warns:

t.cpp(10,15): warning: constructor parameter 'a' shadows the field 'a' of 'A' [-Wshadow-field-in-constructor]
   10 |         B(int a) : b(a)
      |               ^
t.cpp(4,9): note: previous declaration is here
    4 |     int a;

I know that since C++11 nested classes have access to outer classes as if they were friends, but B is just declared inside A (there is no member object of B in A, how can B constructor param a shadow A member a ?

Best Answer

Does a constructor parameter of a nested class shadow members of the enclosing class?

Yes.

Namelookup needs no A instance in B. Because B is nested inside A unqualified name lookup finds A::a.

From cppreference:

For a name used anywhere in class definition (including base class specifiers and nested class definitions), except inside a member function body, a default argument of a member function, exception specification of a member function, or default member initializer, where the member may belong to a nested class whose definition is in the body of the enclosing class, the following scopes are searched:

a) the body of the class in which the name is used until the point of use,

b) the entire body of its base class(es), recursing into their bases when no declarations are found,

c) if this class is nested, the body of the enclosing class until the definition of this class and the entire body of the base class(es) of the enclosing class,

[...]

c) means that an unqualified unshadowed a inside B refers to A::a. Your code works because int a shadows A::a and because in the initializer list b(a) uses the constructor parameter called a.

That the enclosing class is a friend does not matter at this point, because access comes after namelookup. As Jarod42 pointed out, you can modify the code (rename the parameter but keep b(a)) to get an error because A::a is non static.

Related Solutions

Java – Inner Class vs Static Nested Class

From the Java Tutorial:

Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are simply called static nested classes. Non-static nested classes are called inner classes.

Static nested classes are accessed using the enclosing class name:

OuterClass.StaticNestedClass

For example, to create an object for the static nested class, use this syntax:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Objects that are instances of an inner class exist within an instance of the outer class. Consider the following classes:

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance.

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:

OuterClass outerObject = new OuterClass()
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

see: Java Tutorial - Nested Classes

For completeness note that there is also such a thing as an inner class without an enclosing instance:

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

Here, new A() { ... } is an inner class defined in a static context and does not have an enclosing instance.

C++ – What Does the explicit Keyword Mean?

The compiler is allowed to make one implicit conversion to resolve the parameters to a function. This means that the compiler can use constructors callable with a single parameter to convert from one type to another in order to get the right type for a parameter.

Here's an example with converting constructors that shows how it works:

struct Foo {
    // Single parameter constructor, can be used as an implicit conversion.
    // Such a constructor is called "converting constructor".
    Foo(int x) {}
};
struct Faz {
    // Also a converting constructor.
    Faz(Foo foo) {}
};

// The parameter is of type Foo, not of type int, so it looks like
// we have to pass a Foo.
void bar(Foo foo);

int main() {
    // However, the converting constructor allows us to pass an int.
    bar(42);
    // Also allowed thanks to the converting constructor.
    Foo foo = 42;
    // Error! This would require two conversions (int -> Foo -> Faz).
    Faz faz = 42;
}

Prefixing the explicit keyword to the constructor prevents the compiler from using that constructor for implicit conversions. Adding it to the above class will create a compiler error at the function call bar(42). It is now necessary to call for conversion explicitly with bar(Foo(42))

The reason you might want to do this is to avoid accidental construction that can hide bugs.
Contrived example:

You have a MyString class with a constructor that constructs a string of the given size. You have a function print(const MyString&) (as well as an overload print (char *string)), and you call print(3) (when you actually intended to call print("3")). You expect it to print "3", but it prints an empty string of length 3 instead.

Best Answer

Related Solutions

Java – Inner Class vs Static Nested Class

C++ – What Does the explicit Keyword Mean?

Related Question