Explicit type conversion (cast notation)

cast.cpp

struct Parent { virtual ~Parent() = default; };
struct Child : private virtual Parent { };

int main()
{
    Child c0;
    
    Parent& p0 = static_cast<Parent&>(c0); // FAILS, Parent is inaccessible
    
    Parent& p1 = (Parent&)(c0); // OK ( [expr.cast]/p4.6 ), chooses static_cast
    
    Child&  c1 = (Child&)(p1)   // FAILS, chooses static_cast, but that fails
                                // because Parent is a virtual base ( [expr.static.cast]/p2 )
                                // (NOT because it is inaccessible)
                                    
    Child&  c2 = dynamic_cast<Child&>(p1); // FAILS, dynamic_cast can be used with a virtual base,
                                           // but Parent is still private and so the downcast
                                           // is not allowed.
                                           // Also, cast notation doesn't consider dynamic_cast
}

If you're casting to a reference through cast notation and it chooses static_cast, the cast can be successful even if the target type is an inaccessible base.

static_cast can be used to convert a base class to a derived class (downcast), but not if the base class is virtual.