Changing Function Access Mode in Derived Class

Question

Consider the following snippet:

struct Base {   virtual ~Base() {}    virtual void Foo() const = 0; // Public };  class Child : public Base {   virtual void Foo() const {} // Private };  int main() {   Child child;    child.Foo(); // Won't work. Foo is private in this context.    static_cast<Base&> (child).Foo(); // Okay. Foo is public in this context. } 

Is this legal C++? "This" being changing the virtual function's access mode in the derived class.

Answer 1

This is legal C++, §11.6/1 says:

Access is checked at the call point using the type of the expression used to denote the object for which the member function is called (B* in the example above). The access of the member function in the class in which it was defined (D in the example above) is in general not known.

As you noted, Child::Foo() is thus still accessible via the base class, which is in most cases undesired:

 Child* c = new Child;  Base* b = c;  c->Foo(); // doesn't work, Child::Foo() is private  b->Foo(); // works, calls Child::Foo() 

Basically, the declaration you refer to in the expression dictates the access mode - but virtual functions undermine that as another function then the named one may actually be invoked.

Answer 2

Yes, changing the access mode in derived classes is legal.

This is similar in form but different in intent to the Non-Virtual Interface idiom. Some rationale is given here:

The point is that virtual functions exist to allow customization; unless they also need to be invoked directly from within derived classes' code, there's no need to ever make them anything but private.

As to why you would actually make something public in base but private in derived without private or protected inheritance is beyond me.