Error with nested class inheritance

Question

class A {}; class B : private A {}; class C : private B { public:     class D : private A {}; // Error here }; 

This code gives the following error (in VS 2013):

nested.cpp(8) : error C2247: 'A' not accessible because 'B' uses 'private' to inherit from 'A'

It gets fixed if I change the definition of D like this:

class D : private ::A {}; 

Is this correct behavior, and if so why?

At first I thought it was because C inherits privately from B which would hide the base classes. But if I eliminate the "middle man" class B and just use this:

class A {}; class C : private A { public:     class D : private A {}; }; 

The error goes away.

Answer 1

Quote from cppreference:

A name that is private according to unqualified name lookup, may be accessible through qualified name lookup

With that in mind lets see how the unqualified name lookup would work for the first example:

class A {};  class B : private A {};  class C : private B { public:     class D : private A {}; // Error here }; 

1. A is looked up within the scope of C. Had it been defined there, there would be no problem.
2. It figures out A is privately inherited by it's base (private) class B and hence throws a compiler error. Clang says:

    note: constrained by private inheritance here: class B : private A {}; 

Again, as per the quote it should work, if you use fully qualified name, like you have shown

class D : private ::A {}; 

And as for your last example:

class A {};  class C : private A { public:     class D : private A {}; }; 

It works because, the name lookup works for all names that are part of the same class. To quote from cppreference again:

All members of a class (bodies of member functions, initializers of member objects, and the entire nested class definitions) have access to all the names to which a class can access.

Answer 2

It's a matter of scopes during name lookup:

• When you use ::A it's a fully qualified name, thus you are explicitly referring to the global namespace and picking A up from there.

• When you inherit from A, C (let me say) sees A and you can directly refer to the A name within C with an unqualified name.

• When you inherit from B, C sees B and A is private in its scope. It's private, but it exists. Because A is an unqualified name and is looked for first of all in that scope, it happens to be found and unaccessible, thus the error.